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/>.
28 #include "smbd/globals.h"
29 #include "../libcli/auth/libcli_auth.h"
31 extern enum protocol_types Protocol;
33 #define DIR_ENTRY_SAFETY_MARGIN 4096
35 static char *store_file_unix_basic(connection_struct *conn,
38 const SMB_STRUCT_STAT *psbuf);
40 static char *store_file_unix_basic_info2(connection_struct *conn,
43 const SMB_STRUCT_STAT *psbuf);
45 /********************************************************************
46 Roundup a value to the nearest allocation roundup size boundary.
47 Only do this for Windows clients.
48 ********************************************************************/
50 uint64_t smb_roundup(connection_struct *conn, uint64_t val)
52 uint64_t rval = lp_allocation_roundup_size(SNUM(conn));
54 /* Only roundup for Windows clients. */
55 enum remote_arch_types ra_type = get_remote_arch();
56 if (rval && (ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
57 val = SMB_ROUNDUP(val,rval);
62 /****************************************************************************
63 Utility functions for dealing with extended attributes.
64 ****************************************************************************/
66 /****************************************************************************
67 Refuse to allow clients to overwrite our private xattrs.
68 ****************************************************************************/
70 static bool samba_private_attr_name(const char *unix_ea_name)
72 static const char * const prohibited_ea_names[] = {
73 SAMBA_POSIX_INHERITANCE_EA_NAME,
74 SAMBA_XATTR_DOS_ATTRIB,
75 SAMBA_XATTR_DOSTIMESTAMPS,
81 for (i = 0; prohibited_ea_names[i]; i++) {
82 if (strequal( prohibited_ea_names[i], unix_ea_name))
85 if (StrnCaseCmp(unix_ea_name, SAMBA_XATTR_DOSSTREAM_PREFIX,
86 strlen(SAMBA_XATTR_DOSSTREAM_PREFIX)) == 0) {
92 /****************************************************************************
93 Get one EA value. Fill in a struct ea_struct.
94 ****************************************************************************/
96 NTSTATUS get_ea_value(TALLOC_CTX *mem_ctx, connection_struct *conn,
97 files_struct *fsp, const char *fname,
98 const char *ea_name, struct ea_struct *pea)
100 /* Get the value of this xattr. Max size is 64k. */
101 size_t attr_size = 256;
107 val = TALLOC_REALLOC_ARRAY(mem_ctx, val, char, attr_size);
109 return NT_STATUS_NO_MEMORY;
112 if (fsp && fsp->fh->fd != -1) {
113 sizeret = SMB_VFS_FGETXATTR(fsp, ea_name, val, attr_size);
115 sizeret = SMB_VFS_GETXATTR(conn, fname, ea_name, val, attr_size);
118 if (sizeret == -1 && errno == ERANGE && attr_size != 65536) {
124 return map_nt_error_from_unix(errno);
127 DEBUG(10,("get_ea_value: EA %s is of length %u\n", ea_name, (unsigned int)sizeret));
128 dump_data(10, (uint8 *)val, sizeret);
131 if (strnequal(ea_name, "user.", 5)) {
132 pea->name = talloc_strdup(mem_ctx, &ea_name[5]);
134 pea->name = talloc_strdup(mem_ctx, ea_name);
136 if (pea->name == NULL) {
138 return NT_STATUS_NO_MEMORY;
140 pea->value.data = (unsigned char *)val;
141 pea->value.length = (size_t)sizeret;
145 NTSTATUS get_ea_names_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn,
146 files_struct *fsp, const char *fname,
147 char ***pnames, size_t *pnum_names)
149 /* Get a list of all xattrs. Max namesize is 64k. */
150 size_t ea_namelist_size = 1024;
151 char *ea_namelist = NULL;
156 ssize_t sizeret = -1;
158 if (!lp_ea_support(SNUM(conn))) {
165 * TALLOC the result early to get the talloc hierarchy right.
168 names = TALLOC_ARRAY(mem_ctx, char *, 1);
170 DEBUG(0, ("talloc failed\n"));
171 return NT_STATUS_NO_MEMORY;
174 while (ea_namelist_size <= 65536) {
176 ea_namelist = TALLOC_REALLOC_ARRAY(
177 names, ea_namelist, char, ea_namelist_size);
178 if (ea_namelist == NULL) {
179 DEBUG(0, ("talloc failed\n"));
181 return NT_STATUS_NO_MEMORY;
184 if (fsp && fsp->fh->fd != -1) {
185 sizeret = SMB_VFS_FLISTXATTR(fsp, ea_namelist,
188 sizeret = SMB_VFS_LISTXATTR(conn, fname, ea_namelist,
192 if ((sizeret == -1) && (errno == ERANGE)) {
193 ea_namelist_size *= 2;
202 return map_nt_error_from_unix(errno);
205 DEBUG(10, ("get_ea_list_from_file: ea_namelist size = %u\n",
206 (unsigned int)sizeret));
216 * Ensure the result is 0-terminated
219 if (ea_namelist[sizeret-1] != '\0') {
221 return NT_STATUS_INTERNAL_ERROR;
229 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
233 tmp = TALLOC_REALLOC_ARRAY(mem_ctx, names, char *, num_names);
235 DEBUG(0, ("talloc failed\n"));
237 return NT_STATUS_NO_MEMORY;
243 for (p = ea_namelist; p - ea_namelist < sizeret; p += strlen(p)+1) {
244 names[num_names++] = p;
248 *pnum_names = num_names;
252 /****************************************************************************
253 Return a linked list of the total EA's. Plus the total size
254 ****************************************************************************/
256 static struct ea_list *get_ea_list_from_file(TALLOC_CTX *mem_ctx, connection_struct *conn, files_struct *fsp,
257 const char *fname, size_t *pea_total_len)
259 /* Get a list of all xattrs. Max namesize is 64k. */
262 struct ea_list *ea_list_head = NULL;
267 if (!lp_ea_support(SNUM(conn))) {
271 status = get_ea_names_from_file(talloc_tos(), conn, fsp, fname,
274 if (!NT_STATUS_IS_OK(status) || (num_names == 0)) {
278 for (i=0; i<num_names; i++) {
279 struct ea_list *listp;
282 if (strnequal(names[i], "system.", 7)
283 || samba_private_attr_name(names[i]))
286 listp = TALLOC_P(mem_ctx, struct ea_list);
291 if (!NT_STATUS_IS_OK(get_ea_value(mem_ctx, conn, fsp,
297 push_ascii_fstring(dos_ea_name, listp->ea.name);
300 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
302 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len "
303 "= %u\n", (unsigned int)*pea_total_len, dos_ea_name,
304 (unsigned int)listp->ea.value.length));
306 DLIST_ADD_END(ea_list_head, listp, struct ea_list *);
310 /* Add on 4 for total length. */
311 if (*pea_total_len) {
315 DEBUG(10, ("get_ea_list_from_file: total_len = %u\n",
316 (unsigned int)*pea_total_len));
321 /****************************************************************************
322 Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
324 ****************************************************************************/
326 static unsigned int fill_ea_buffer(TALLOC_CTX *mem_ctx, char *pdata, unsigned int total_data_size,
327 connection_struct *conn, struct ea_list *ea_list)
329 unsigned int ret_data_size = 4;
332 SMB_ASSERT(total_data_size >= 4);
334 if (!lp_ea_support(SNUM(conn))) {
339 for (p = pdata + 4; ea_list; ea_list = ea_list->next) {
342 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
343 dos_namelen = strlen(dos_ea_name);
344 if (dos_namelen > 255 || dos_namelen == 0) {
347 if (ea_list->ea.value.length > 65535) {
350 if (4 + dos_namelen + 1 + ea_list->ea.value.length > total_data_size) {
354 /* We know we have room. */
355 SCVAL(p,0,ea_list->ea.flags);
356 SCVAL(p,1,dos_namelen);
357 SSVAL(p,2,ea_list->ea.value.length);
358 fstrcpy(p+4, dos_ea_name);
359 memcpy( p + 4 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
361 total_data_size -= 4 + dos_namelen + 1 + ea_list->ea.value.length;
362 p += 4 + dos_namelen + 1 + ea_list->ea.value.length;
365 ret_data_size = PTR_DIFF(p, pdata);
366 DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size ));
367 SIVAL(pdata,0,ret_data_size);
368 return ret_data_size;
371 static NTSTATUS fill_ea_chained_buffer(TALLOC_CTX *mem_ctx,
373 unsigned int total_data_size,
374 unsigned int *ret_data_size,
375 connection_struct *conn,
376 struct ea_list *ea_list)
378 uint8_t *p = (uint8_t *)pdata;
379 uint8_t *last_start = NULL;
383 if (!lp_ea_support(SNUM(conn))) {
384 return NT_STATUS_NO_EAS_ON_FILE;
387 for (; ea_list; ea_list = ea_list->next) {
393 SIVAL(last_start, 0, PTR_DIFF(p, last_start));
397 push_ascii_fstring(dos_ea_name, ea_list->ea.name);
398 dos_namelen = strlen(dos_ea_name);
399 if (dos_namelen > 255 || dos_namelen == 0) {
400 return NT_STATUS_INTERNAL_ERROR;
402 if (ea_list->ea.value.length > 65535) {
403 return NT_STATUS_INTERNAL_ERROR;
406 this_size = 0x08 + dos_namelen + 1 + ea_list->ea.value.length;
409 size_t pad = 4 - (this_size % 4);
413 if (this_size > total_data_size) {
414 return NT_STATUS_INFO_LENGTH_MISMATCH;
417 /* We know we have room. */
418 SIVAL(p, 0x00, 0); /* next offset */
419 SCVAL(p, 0x04, ea_list->ea.flags);
420 SCVAL(p, 0x05, dos_namelen);
421 SSVAL(p, 0x06, ea_list->ea.value.length);
422 fstrcpy((char *)(p+0x08), dos_ea_name);
423 memcpy(p + 0x08 + dos_namelen + 1, ea_list->ea.value.data, ea_list->ea.value.length);
425 total_data_size -= this_size;
429 *ret_data_size = PTR_DIFF(p, pdata);
430 DEBUG(10,("fill_ea_chained_buffer: data_size = %u\n", *ret_data_size));
434 static unsigned int estimate_ea_size(connection_struct *conn, files_struct *fsp, const char *fname)
436 size_t total_ea_len = 0;
437 TALLOC_CTX *mem_ctx = NULL;
439 if (!lp_ea_support(SNUM(conn))) {
442 mem_ctx = talloc_tos();
443 (void)get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
447 /****************************************************************************
448 Ensure the EA name is case insensitive by matching any existing EA name.
449 ****************************************************************************/
451 static void canonicalize_ea_name(connection_struct *conn, files_struct *fsp, const char *fname, fstring unix_ea_name)
454 TALLOC_CTX *mem_ctx = talloc_tos();
455 struct ea_list *ea_list = get_ea_list_from_file(mem_ctx, conn, fsp, fname, &total_ea_len);
457 for (; ea_list; ea_list = ea_list->next) {
458 if (strequal(&unix_ea_name[5], ea_list->ea.name)) {
459 DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
460 &unix_ea_name[5], ea_list->ea.name));
461 safe_strcpy(&unix_ea_name[5], ea_list->ea.name, sizeof(fstring)-6);
467 /****************************************************************************
468 Set or delete an extended attribute.
469 ****************************************************************************/
471 NTSTATUS set_ea(connection_struct *conn, files_struct *fsp,
472 const struct smb_filename *smb_fname, struct ea_list *ea_list)
476 if (!lp_ea_support(SNUM(conn))) {
477 return NT_STATUS_EAS_NOT_SUPPORTED;
480 /* For now setting EAs on streams isn't supported. */
481 fname = smb_fname->base_name;
483 for (;ea_list; ea_list = ea_list->next) {
485 fstring unix_ea_name;
487 fstrcpy(unix_ea_name, "user."); /* All EA's must start with user. */
488 fstrcat(unix_ea_name, ea_list->ea.name);
490 canonicalize_ea_name(conn, fsp, fname, unix_ea_name);
492 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name, (unsigned int)ea_list->ea.value.length));
494 if (samba_private_attr_name(unix_ea_name)) {
495 DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name));
496 return NT_STATUS_ACCESS_DENIED;
499 if (ea_list->ea.value.length == 0) {
500 /* Remove the attribute. */
501 if (fsp && (fsp->fh->fd != -1)) {
502 DEBUG(10,("set_ea: deleting ea name %s on "
503 "file %s by file descriptor.\n",
504 unix_ea_name, fsp_str_dbg(fsp)));
505 ret = SMB_VFS_FREMOVEXATTR(fsp, unix_ea_name);
507 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
508 unix_ea_name, fname));
509 ret = SMB_VFS_REMOVEXATTR(conn, fname, unix_ea_name);
512 /* Removing a non existent attribute always succeeds. */
513 if (ret == -1 && errno == ENOATTR) {
514 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
520 if (fsp && (fsp->fh->fd != -1)) {
521 DEBUG(10,("set_ea: setting ea name %s on file "
522 "%s by file descriptor.\n",
523 unix_ea_name, fsp_str_dbg(fsp)));
524 ret = SMB_VFS_FSETXATTR(fsp, unix_ea_name,
525 ea_list->ea.value.data, ea_list->ea.value.length, 0);
527 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
528 unix_ea_name, fname));
529 ret = SMB_VFS_SETXATTR(conn, fname, unix_ea_name,
530 ea_list->ea.value.data, ea_list->ea.value.length, 0);
536 if (errno == ENOTSUP) {
537 return NT_STATUS_EAS_NOT_SUPPORTED;
540 return map_nt_error_from_unix(errno);
546 /****************************************************************************
547 Read a list of EA names from an incoming data buffer. Create an ea_list with them.
548 ****************************************************************************/
550 static struct ea_list *read_ea_name_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
552 struct ea_list *ea_list_head = NULL;
553 size_t converted_size, offset = 0;
555 while (offset + 2 < data_size) {
556 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
557 unsigned int namelen = CVAL(pdata,offset);
559 offset++; /* Go past the namelen byte. */
561 /* integer wrap paranioa. */
562 if ((offset + namelen < offset) || (offset + namelen < namelen) ||
563 (offset > data_size) || (namelen > data_size) ||
564 (offset + namelen >= data_size)) {
567 /* Ensure the name is null terminated. */
568 if (pdata[offset + namelen] != '\0') {
571 if (!pull_ascii_talloc(ctx, &eal->ea.name, &pdata[offset],
573 DEBUG(0,("read_ea_name_list: pull_ascii_talloc "
574 "failed: %s", strerror(errno)));
580 offset += (namelen + 1); /* Go past the name + terminating zero. */
581 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
582 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal->ea.name));
588 /****************************************************************************
589 Read one EA list entry from the buffer.
590 ****************************************************************************/
592 struct ea_list *read_ea_list_entry(TALLOC_CTX *ctx, const char *pdata, size_t data_size, size_t *pbytes_used)
594 struct ea_list *eal = TALLOC_ZERO_P(ctx, struct ea_list);
596 unsigned int namelen;
597 size_t converted_size;
607 eal->ea.flags = CVAL(pdata,0);
608 namelen = CVAL(pdata,1);
609 val_len = SVAL(pdata,2);
611 if (4 + namelen + 1 + val_len > data_size) {
615 /* Ensure the name is null terminated. */
616 if (pdata[namelen + 4] != '\0') {
619 if (!pull_ascii_talloc(ctx, &eal->ea.name, pdata + 4, &converted_size)) {
620 DEBUG(0,("read_ea_list_entry: pull_ascii_talloc failed: %s",
627 eal->ea.value = data_blob_talloc(eal, NULL, (size_t)val_len + 1);
628 if (!eal->ea.value.data) {
632 memcpy(eal->ea.value.data, pdata + 4 + namelen + 1, val_len);
634 /* Ensure we're null terminated just in case we print the value. */
635 eal->ea.value.data[val_len] = '\0';
636 /* But don't count the null. */
637 eal->ea.value.length--;
640 *pbytes_used = 4 + namelen + 1 + val_len;
643 DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal->ea.name));
644 dump_data(10, eal->ea.value.data, eal->ea.value.length);
649 /****************************************************************************
650 Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
651 ****************************************************************************/
653 static struct ea_list *read_ea_list(TALLOC_CTX *ctx, const char *pdata, size_t data_size)
655 struct ea_list *ea_list_head = NULL;
657 size_t bytes_used = 0;
659 while (offset < data_size) {
660 struct ea_list *eal = read_ea_list_entry(ctx, pdata + offset, data_size - offset, &bytes_used);
666 DLIST_ADD_END(ea_list_head, eal, struct ea_list *);
667 offset += bytes_used;
673 /****************************************************************************
674 Count the total EA size needed.
675 ****************************************************************************/
677 static size_t ea_list_size(struct ea_list *ealist)
680 struct ea_list *listp;
683 for (listp = ealist; listp; listp = listp->next) {
684 push_ascii_fstring(dos_ea_name, listp->ea.name);
685 ret += 4 + strlen(dos_ea_name) + 1 + listp->ea.value.length;
687 /* Add on 4 for total length. */
695 /****************************************************************************
696 Return a union of EA's from a file list and a list of names.
697 The TALLOC context for the two lists *MUST* be identical as we steal
698 memory from one list to add to another. JRA.
699 ****************************************************************************/
701 static struct ea_list *ea_list_union(struct ea_list *name_list, struct ea_list *file_list, size_t *total_ea_len)
703 struct ea_list *nlistp, *flistp;
705 for (nlistp = name_list; nlistp; nlistp = nlistp->next) {
706 for (flistp = file_list; flistp; flistp = flistp->next) {
707 if (strequal(nlistp->ea.name, flistp->ea.name)) {
713 /* Copy the data from this entry. */
714 nlistp->ea.flags = flistp->ea.flags;
715 nlistp->ea.value = flistp->ea.value;
718 nlistp->ea.flags = 0;
719 ZERO_STRUCT(nlistp->ea.value);
723 *total_ea_len = ea_list_size(name_list);
727 /****************************************************************************
728 Send the required number of replies back.
729 We assume all fields other than the data fields are
730 set correctly for the type of call.
731 HACK ! Always assumes smb_setup field is zero.
732 ****************************************************************************/
734 void send_trans2_replies(connection_struct *conn,
735 struct smb_request *req,
742 /* As we are using a protocol > LANMAN1 then the max_send
743 variable must have been set in the sessetupX call.
744 This takes precedence over the max_xmit field in the
745 global struct. These different max_xmit variables should
746 be merged as this is now too confusing */
748 int data_to_send = datasize;
749 int params_to_send = paramsize;
751 const char *pp = params;
752 const char *pd = pdata;
753 int params_sent_thistime, data_sent_thistime, total_sent_thistime;
754 int alignment_offset = 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
755 int data_alignment_offset = 0;
756 bool overflow = False;
757 struct smbd_server_connection *sconn = smbd_server_conn;
758 int max_send = sconn->smb1.sessions.max_send;
760 /* Modify the data_to_send and datasize and set the error if
761 we're trying to send more than max_data_bytes. We still send
762 the part of the packet(s) that fit. Strange, but needed
765 if (max_data_bytes > 0 && datasize > max_data_bytes) {
766 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
767 max_data_bytes, datasize ));
768 datasize = data_to_send = max_data_bytes;
772 /* If there genuinely are no parameters or data to send just send the empty packet */
774 if(params_to_send == 0 && data_to_send == 0) {
775 reply_outbuf(req, 10, 0);
776 show_msg((char *)req->outbuf);
777 if (!srv_send_smb(smbd_server_fd(),
780 IS_CONN_ENCRYPTED(conn),
782 exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
784 TALLOC_FREE(req->outbuf);
788 /* When sending params and data ensure that both are nicely aligned */
789 /* Only do this alignment when there is also data to send - else
790 can cause NT redirector problems. */
792 if (((params_to_send % 4) != 0) && (data_to_send != 0))
793 data_alignment_offset = 4 - (params_to_send % 4);
795 /* Space is bufsize minus Netbios over TCP header minus SMB header */
796 /* The alignment_offset is to align the param bytes on an even byte
797 boundary. NT 4.0 Beta needs this to work correctly. */
799 useable_space = max_send - (smb_size
802 + data_alignment_offset);
804 if (useable_space < 0) {
805 DEBUG(0, ("send_trans2_replies failed sanity useable_space "
806 "= %d!!!", useable_space));
807 exit_server_cleanly("send_trans2_replies: Not enough space");
810 while (params_to_send || data_to_send) {
811 /* Calculate whether we will totally or partially fill this packet */
813 total_sent_thistime = params_to_send + data_to_send;
815 /* We can never send more than useable_space */
817 * Note that 'useable_space' does not include the alignment offsets,
818 * but we must include the alignment offsets in the calculation of
819 * the length of the data we send over the wire, as the alignment offsets
820 * are sent here. Fix from Marc_Jacobsen@hp.com.
823 total_sent_thistime = MIN(total_sent_thistime, useable_space);
825 reply_outbuf(req, 10, total_sent_thistime + alignment_offset
826 + data_alignment_offset);
829 * We might have SMBtrans2s in req which was transferred to
830 * the outbuf, fix that.
832 SCVAL(req->outbuf, smb_com, SMBtrans2);
834 /* Set total params and data to be sent */
835 SSVAL(req->outbuf,smb_tprcnt,paramsize);
836 SSVAL(req->outbuf,smb_tdrcnt,datasize);
838 /* Calculate how many parameters and data we can fit into
839 * this packet. Parameters get precedence
842 params_sent_thistime = MIN(params_to_send,useable_space);
843 data_sent_thistime = useable_space - params_sent_thistime;
844 data_sent_thistime = MIN(data_sent_thistime,data_to_send);
846 SSVAL(req->outbuf,smb_prcnt, params_sent_thistime);
848 /* smb_proff is the offset from the start of the SMB header to the
849 parameter bytes, however the first 4 bytes of outbuf are
850 the Netbios over TCP header. Thus use smb_base() to subtract
851 them from the calculation */
853 SSVAL(req->outbuf,smb_proff,
854 ((smb_buf(req->outbuf)+alignment_offset)
855 - smb_base(req->outbuf)));
857 if(params_sent_thistime == 0)
858 SSVAL(req->outbuf,smb_prdisp,0);
860 /* Absolute displacement of param bytes sent in this packet */
861 SSVAL(req->outbuf,smb_prdisp,pp - params);
863 SSVAL(req->outbuf,smb_drcnt, data_sent_thistime);
864 if(data_sent_thistime == 0) {
865 SSVAL(req->outbuf,smb_droff,0);
866 SSVAL(req->outbuf,smb_drdisp, 0);
868 /* The offset of the data bytes is the offset of the
869 parameter bytes plus the number of parameters being sent this time */
870 SSVAL(req->outbuf, smb_droff,
871 ((smb_buf(req->outbuf)+alignment_offset)
872 - smb_base(req->outbuf))
873 + params_sent_thistime + data_alignment_offset);
874 SSVAL(req->outbuf,smb_drdisp, pd - pdata);
877 /* Initialize the padding for alignment */
879 if (alignment_offset != 0) {
880 memset(smb_buf(req->outbuf), 0, alignment_offset);
883 /* Copy the param bytes into the packet */
885 if(params_sent_thistime) {
886 memcpy((smb_buf(req->outbuf)+alignment_offset), pp,
887 params_sent_thistime);
890 /* Copy in the data bytes */
891 if(data_sent_thistime) {
892 if (data_alignment_offset != 0) {
893 memset((smb_buf(req->outbuf)+alignment_offset+
894 params_sent_thistime), 0,
895 data_alignment_offset);
897 memcpy(smb_buf(req->outbuf)+alignment_offset
898 +params_sent_thistime+data_alignment_offset,
899 pd,data_sent_thistime);
902 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
903 params_sent_thistime, data_sent_thistime, useable_space));
904 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
905 params_to_send, data_to_send, paramsize, datasize));
908 error_packet_set((char *)req->outbuf,
909 ERRDOS,ERRbufferoverflow,
910 STATUS_BUFFER_OVERFLOW,
914 /* Send the packet */
915 show_msg((char *)req->outbuf);
916 if (!srv_send_smb(smbd_server_fd(),
919 IS_CONN_ENCRYPTED(conn),
921 exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
923 TALLOC_FREE(req->outbuf);
925 pp += params_sent_thistime;
926 pd += data_sent_thistime;
928 params_to_send -= params_sent_thistime;
929 data_to_send -= data_sent_thistime;
932 if(params_to_send < 0 || data_to_send < 0) {
933 DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
934 params_to_send, data_to_send));
942 /****************************************************************************
943 Reply to a TRANSACT2_OPEN.
944 ****************************************************************************/
946 static void call_trans2open(connection_struct *conn,
947 struct smb_request *req,
948 char **pparams, int total_params,
949 char **ppdata, int total_data,
950 unsigned int max_data_bytes)
952 struct smb_filename *smb_fname = NULL;
953 char *params = *pparams;
954 char *pdata = *ppdata;
959 bool return_additional_info;
972 struct ea_list *ea_list = NULL;
977 uint32 create_disposition;
978 uint32 create_options = 0;
979 TALLOC_CTX *ctx = talloc_tos();
982 * Ensure we have enough parameters to perform the operation.
985 if (total_params < 29) {
986 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
990 flags = SVAL(params, 0);
991 deny_mode = SVAL(params, 2);
992 open_attr = SVAL(params,6);
993 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
994 if (oplock_request) {
995 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
999 return_additional_info = BITSETW(params,0);
1000 open_sattr = SVAL(params, 4);
1001 open_time = make_unix_date3(params+8);
1003 open_ofun = SVAL(params,12);
1004 open_size = IVAL(params,14);
1005 pname = ¶ms[28];
1008 reply_doserror(req, ERRSRV, ERRaccess);
1012 srvstr_get_path(ctx, params, req->flags2, &fname, pname,
1013 total_params - 28, STR_TERMINATE,
1015 if (!NT_STATUS_IS_OK(status)) {
1016 reply_nterror(req, status);
1020 DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
1021 fname, (unsigned int)deny_mode, (unsigned int)open_attr,
1022 (unsigned int)open_ofun, open_size));
1024 status = filename_convert(ctx,
1026 req->flags2 & FLAGS2_DFS_PATHNAMES,
1031 if (!NT_STATUS_IS_OK(status)) {
1032 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
1033 reply_botherror(req,
1034 NT_STATUS_PATH_NOT_COVERED,
1035 ERRSRV, ERRbadpath);
1038 reply_nterror(req, status);
1042 if (open_ofun == 0) {
1043 reply_nterror(req, NT_STATUS_OBJECT_NAME_COLLISION);
1047 if (!map_open_params_to_ntcreate(smb_fname, deny_mode, open_ofun,
1048 &access_mask, &share_mode,
1049 &create_disposition,
1051 reply_doserror(req, ERRDOS, ERRbadaccess);
1055 /* Any data in this call is an EA list. */
1056 if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
1057 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
1061 if (total_data != 4) {
1062 if (total_data < 10) {
1063 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1067 if (IVAL(pdata,0) > total_data) {
1068 DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
1069 IVAL(pdata,0), (unsigned int)total_data));
1070 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1074 ea_list = read_ea_list(talloc_tos(), pdata + 4,
1077 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1080 } else if (IVAL(pdata,0) != 4) {
1081 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
1085 status = SMB_VFS_CREATE_FILE(
1088 0, /* root_dir_fid */
1089 smb_fname, /* fname */
1090 access_mask, /* access_mask */
1091 share_mode, /* share_access */
1092 create_disposition, /* create_disposition*/
1093 create_options, /* create_options */
1094 open_attr, /* file_attributes */
1095 oplock_request, /* oplock_request */
1096 open_size, /* allocation_size */
1098 ea_list, /* ea_list */
1100 &smb_action); /* psbuf */
1102 if (!NT_STATUS_IS_OK(status)) {
1103 if (open_was_deferred(req->mid)) {
1104 /* We have re-scheduled this call. */
1107 reply_openerror(req, status);
1111 size = get_file_size_stat(&smb_fname->st);
1112 fattr = dos_mode(conn, smb_fname);
1113 mtime = convert_timespec_to_time_t(smb_fname->st.st_ex_mtime);
1114 inode = smb_fname->st.st_ex_ino;
1116 close_file(req, fsp, ERROR_CLOSE);
1117 reply_doserror(req, ERRDOS,ERRnoaccess);
1121 /* Realloc the size of parameters and data we will return */
1122 *pparams = (char *)SMB_REALLOC(*pparams, 30);
1123 if(*pparams == NULL ) {
1124 reply_nterror(req, NT_STATUS_NO_MEMORY);
1129 SSVAL(params,0,fsp->fnum);
1130 SSVAL(params,2,fattr);
1131 srv_put_dos_date2(params,4, mtime);
1132 SIVAL(params,8, (uint32)size);
1133 SSVAL(params,12,deny_mode);
1134 SSVAL(params,14,0); /* open_type - file or directory. */
1135 SSVAL(params,16,0); /* open_state - only valid for IPC device. */
1137 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
1138 smb_action |= EXTENDED_OPLOCK_GRANTED;
1141 SSVAL(params,18,smb_action);
1144 * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
1146 SIVAL(params,20,inode);
1147 SSVAL(params,24,0); /* Padding. */
1149 uint32 ea_size = estimate_ea_size(conn, fsp,
1150 fsp->fsp_name->base_name);
1151 SIVAL(params, 26, ea_size);
1153 SIVAL(params, 26, 0);
1156 /* Send the required number of replies */
1157 send_trans2_replies(conn, req, params, 30, *ppdata, 0, max_data_bytes);
1159 TALLOC_FREE(smb_fname);
1162 /*********************************************************
1163 Routine to check if a given string matches exactly.
1164 as a special case a mask of "." does NOT match. That
1165 is required for correct wildcard semantics
1166 Case can be significant or not.
1167 **********************************************************/
1169 static bool exact_match(bool has_wild,
1170 bool case_sensitive,
1174 if (mask[0] == '.' && mask[1] == 0) {
1182 if (case_sensitive) {
1183 return strcmp(str,mask)==0;
1185 return StrCaseCmp(str,mask) == 0;
1189 /****************************************************************************
1190 Return the filetype for UNIX extensions.
1191 ****************************************************************************/
1193 static uint32 unix_filetype(mode_t mode)
1196 return UNIX_TYPE_FILE;
1197 else if(S_ISDIR(mode))
1198 return UNIX_TYPE_DIR;
1200 else if(S_ISLNK(mode))
1201 return UNIX_TYPE_SYMLINK;
1204 else if(S_ISCHR(mode))
1205 return UNIX_TYPE_CHARDEV;
1208 else if(S_ISBLK(mode))
1209 return UNIX_TYPE_BLKDEV;
1212 else if(S_ISFIFO(mode))
1213 return UNIX_TYPE_FIFO;
1216 else if(S_ISSOCK(mode))
1217 return UNIX_TYPE_SOCKET;
1220 DEBUG(0,("unix_filetype: unknown filetype %u\n", (unsigned)mode));
1221 return UNIX_TYPE_UNKNOWN;
1224 /****************************************************************************
1225 Map wire perms onto standard UNIX permissions. Obey share restrictions.
1226 ****************************************************************************/
1228 enum perm_type { PERM_NEW_FILE, PERM_NEW_DIR, PERM_EXISTING_FILE, PERM_EXISTING_DIR};
1230 static NTSTATUS unix_perms_from_wire( connection_struct *conn,
1231 const SMB_STRUCT_STAT *psbuf,
1233 enum perm_type ptype,
1238 if (perms == SMB_MODE_NO_CHANGE) {
1239 if (!VALID_STAT(*psbuf)) {
1240 return NT_STATUS_INVALID_PARAMETER;
1242 *ret_perms = psbuf->st_ex_mode;
1243 return NT_STATUS_OK;
1247 ret |= ((perms & UNIX_X_OTH ) ? S_IXOTH : 0);
1248 ret |= ((perms & UNIX_W_OTH ) ? S_IWOTH : 0);
1249 ret |= ((perms & UNIX_R_OTH ) ? S_IROTH : 0);
1250 ret |= ((perms & UNIX_X_GRP ) ? S_IXGRP : 0);
1251 ret |= ((perms & UNIX_W_GRP ) ? S_IWGRP : 0);
1252 ret |= ((perms & UNIX_R_GRP ) ? S_IRGRP : 0);
1253 ret |= ((perms & UNIX_X_USR ) ? S_IXUSR : 0);
1254 ret |= ((perms & UNIX_W_USR ) ? S_IWUSR : 0);
1255 ret |= ((perms & UNIX_R_USR ) ? S_IRUSR : 0);
1257 ret |= ((perms & UNIX_STICKY ) ? S_ISVTX : 0);
1260 ret |= ((perms & UNIX_SET_GID ) ? S_ISGID : 0);
1263 ret |= ((perms & UNIX_SET_UID ) ? S_ISUID : 0);
1268 /* Apply mode mask */
1269 ret &= lp_create_mask(SNUM(conn));
1270 /* Add in force bits */
1271 ret |= lp_force_create_mode(SNUM(conn));
1274 ret &= lp_dir_mask(SNUM(conn));
1275 /* Add in force bits */
1276 ret |= lp_force_dir_mode(SNUM(conn));
1278 case PERM_EXISTING_FILE:
1279 /* Apply mode mask */
1280 ret &= lp_security_mask(SNUM(conn));
1281 /* Add in force bits */
1282 ret |= lp_force_security_mode(SNUM(conn));
1284 case PERM_EXISTING_DIR:
1285 /* Apply mode mask */
1286 ret &= lp_dir_security_mask(SNUM(conn));
1287 /* Add in force bits */
1288 ret |= lp_force_dir_security_mode(SNUM(conn));
1293 return NT_STATUS_OK;
1296 /****************************************************************************
1297 Needed to show the msdfs symlinks as directories. Modifies psbuf
1298 to be a directory if it's a msdfs link.
1299 ****************************************************************************/
1301 static bool check_msdfs_link(connection_struct *conn,
1302 const char *pathname,
1303 SMB_STRUCT_STAT *psbuf)
1305 int saved_errno = errno;
1306 if(lp_host_msdfs() &&
1307 lp_msdfs_root(SNUM(conn)) &&
1308 is_msdfs_link(conn, pathname, psbuf)) {
1310 DEBUG(5,("check_msdfs_link: Masquerading msdfs link %s "
1313 psbuf->st_ex_mode = (psbuf->st_ex_mode & 0xFFF) | S_IFDIR;
1314 errno = saved_errno;
1317 errno = saved_errno;
1322 /****************************************************************************
1323 Get a level dependent lanman2 dir entry.
1324 ****************************************************************************/
1326 struct smbd_dirptr_lanman2_state {
1327 connection_struct *conn;
1328 uint32_t info_level;
1329 bool check_mangled_names;
1331 bool got_exact_match;
1334 static bool smbd_dirptr_lanman2_match_fn(TALLOC_CTX *ctx,
1340 struct smbd_dirptr_lanman2_state *state =
1341 (struct smbd_dirptr_lanman2_state *)private_data;
1343 char mangled_name[13]; /* mangled 8.3 name. */
1347 /* Mangle fname if it's an illegal name. */
1348 if (mangle_must_mangle(dname, state->conn->params)) {
1349 ok = name_to_8_3(dname, mangled_name,
1350 true, state->conn->params);
1354 fname = mangled_name;
1359 got_match = exact_match(state->has_wild,
1360 state->conn->case_sensitive,
1362 state->got_exact_match = got_match;
1364 got_match = mask_match(fname, mask,
1365 state->conn->case_sensitive);
1368 if(!got_match && state->check_mangled_names &&
1369 !mangle_is_8_3(fname, false, state->conn->params)) {
1371 * It turns out that NT matches wildcards against
1372 * both long *and* short names. This may explain some
1373 * of the wildcard wierdness from old DOS clients
1374 * that some people have been seeing.... JRA.
1376 /* Force the mangling into 8.3. */
1377 ok = name_to_8_3(fname, mangled_name,
1378 false, state->conn->params);
1383 got_match = exact_match(state->has_wild,
1384 state->conn->case_sensitive,
1385 mangled_name, mask);
1386 state->got_exact_match = got_match;
1388 got_match = mask_match(mangled_name, mask,
1389 state->conn->case_sensitive);
1397 *_fname = talloc_strdup(ctx, fname);
1398 if (*_fname == NULL) {
1405 static bool smbd_dirptr_lanman2_mode_fn(TALLOC_CTX *ctx,
1407 struct smb_filename *smb_fname,
1410 struct smbd_dirptr_lanman2_state *state =
1411 (struct smbd_dirptr_lanman2_state *)private_data;
1412 bool ms_dfs_link = false;
1415 if (INFO_LEVEL_IS_UNIX(state->info_level)) {
1416 if (SMB_VFS_LSTAT(state->conn, smb_fname) != 0) {
1417 DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1418 "Couldn't lstat [%s] (%s)\n",
1419 smb_fname_str_dbg(smb_fname),
1423 } else if (!VALID_STAT(smb_fname->st) &&
1424 SMB_VFS_STAT(state->conn, smb_fname) != 0) {
1425 /* Needed to show the msdfs symlinks as
1428 ms_dfs_link = check_msdfs_link(state->conn,
1429 smb_fname->base_name,
1432 DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1433 "Couldn't stat [%s] (%s)\n",
1434 smb_fname_str_dbg(smb_fname),
1441 mode = dos_mode_msdfs(state->conn, smb_fname);
1443 mode = dos_mode(state->conn, smb_fname);
1450 static bool smbd_marshall_dir_entry(TALLOC_CTX *ctx,
1451 connection_struct *conn,
1453 uint32_t info_level,
1454 struct ea_list *name_list,
1455 bool check_mangled_names,
1456 bool requires_resume_key,
1459 const struct smb_filename *smb_fname,
1460 uint64_t space_remaining,
1467 uint64_t *last_entry_off)
1469 char *p, *q, *pdata = *ppdata;
1471 uint64_t file_size = 0;
1472 uint64_t allocation_size = 0;
1474 struct timespec mdate_ts, adate_ts, cdate_ts, create_date_ts;
1475 time_t mdate = (time_t)0, adate = (time_t)0, create_date = (time_t)0;
1476 time_t c_date = (time_t)0;
1478 char *last_entry_ptr;
1480 uint32_t nt_extmode; /* Used for NT connections instead of mode */
1484 *out_of_space = false;
1486 ZERO_STRUCT(mdate_ts);
1487 ZERO_STRUCT(adate_ts);
1488 ZERO_STRUCT(create_date_ts);
1489 ZERO_STRUCT(cdate_ts);
1491 if (!(mode & aDIR)) {
1492 file_size = get_file_size_stat(&smb_fname->st);
1494 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, NULL, &smb_fname->st);
1496 mdate_ts = smb_fname->st.st_ex_mtime;
1497 adate_ts = smb_fname->st.st_ex_atime;
1498 create_date_ts = get_create_timespec(conn, NULL, smb_fname);
1499 cdate_ts = get_change_timespec(conn, NULL, smb_fname);
1501 if (lp_dos_filetime_resolution(SNUM(conn))) {
1502 dos_filetime_timespec(&create_date_ts);
1503 dos_filetime_timespec(&mdate_ts);
1504 dos_filetime_timespec(&adate_ts);
1505 dos_filetime_timespec(&cdate_ts);
1508 create_date = convert_timespec_to_time_t(create_date_ts);
1509 mdate = convert_timespec_to_time_t(mdate_ts);
1510 adate = convert_timespec_to_time_t(adate_ts);
1511 c_date = convert_timespec_to_time_t(cdate_ts);
1513 /* align the record */
1514 off = PTR_DIFF(pdata, base_data);
1515 pad = (off + (align-1)) & ~(align-1);
1518 /* initialize padding to 0 */
1519 memset(pdata, 0, pad);
1520 space_remaining -= pad;
1529 nt_extmode = mode ? mode : FILE_ATTRIBUTE_NORMAL;
1531 switch (info_level) {
1532 case SMB_FIND_INFO_STANDARD:
1533 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1534 if(requires_resume_key) {
1538 srv_put_dos_date2(p,0,create_date);
1539 srv_put_dos_date2(p,4,adate);
1540 srv_put_dos_date2(p,8,mdate);
1541 SIVAL(p,12,(uint32)file_size);
1542 SIVAL(p,16,(uint32)allocation_size);
1546 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1547 p += ucs2_align(base_data, p, 0);
1549 len = srvstr_push(base_data, flags2, p,
1550 fname, PTR_DIFF(end_data, p),
1552 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1554 SCVAL(nameptr, -1, len - 2);
1556 SCVAL(nameptr, -1, 0);
1560 SCVAL(nameptr, -1, len - 1);
1562 SCVAL(nameptr, -1, 0);
1568 case SMB_FIND_EA_SIZE:
1569 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_SIZE\n"));
1570 if (requires_resume_key) {
1574 srv_put_dos_date2(p,0,create_date);
1575 srv_put_dos_date2(p,4,adate);
1576 srv_put_dos_date2(p,8,mdate);
1577 SIVAL(p,12,(uint32)file_size);
1578 SIVAL(p,16,(uint32)allocation_size);
1581 unsigned int ea_size = estimate_ea_size(conn, NULL,
1582 smb_fname->base_name);
1583 SIVAL(p,22,ea_size); /* Extended attributes */
1587 len = srvstr_push(base_data, flags2,
1588 p, fname, PTR_DIFF(end_data, p),
1589 STR_TERMINATE | STR_NOALIGN);
1590 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1603 SCVAL(nameptr,0,len);
1605 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1608 case SMB_FIND_EA_LIST:
1610 struct ea_list *file_list = NULL;
1613 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_LIST\n"));
1617 if (requires_resume_key) {
1621 srv_put_dos_date2(p,0,create_date);
1622 srv_put_dos_date2(p,4,adate);
1623 srv_put_dos_date2(p,8,mdate);
1624 SIVAL(p,12,(uint32)file_size);
1625 SIVAL(p,16,(uint32)allocation_size);
1627 p += 22; /* p now points to the EA area. */
1629 file_list = get_ea_list_from_file(ctx, conn, NULL,
1630 smb_fname->base_name,
1632 name_list = ea_list_union(name_list, file_list, &ea_len);
1634 /* We need to determine if this entry will fit in the space available. */
1635 /* Max string size is 255 bytes. */
1636 if (PTR_DIFF(p + 255 + ea_len,pdata) > space_remaining) {
1637 *out_of_space = true;
1638 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1639 return False; /* Not finished - just out of space */
1642 /* Push the ea_data followed by the name. */
1643 p += fill_ea_buffer(ctx, p, space_remaining, conn, name_list);
1645 len = srvstr_push(base_data, flags2,
1646 p + 1, fname, PTR_DIFF(end_data, p+1),
1647 STR_TERMINATE | STR_NOALIGN);
1648 if (flags2 & FLAGS2_UNICODE_STRINGS) {
1661 SCVAL(nameptr,0,len);
1663 SCVAL(p,0,0); p += 1; /* Extra zero byte ? - why.. */
1667 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
1668 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1669 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1671 SIVAL(p,0,reskey); p += 4;
1672 put_long_date_timespec(p,create_date_ts); p += 8;
1673 put_long_date_timespec(p,adate_ts); p += 8;
1674 put_long_date_timespec(p,mdate_ts); p += 8;
1675 put_long_date_timespec(p,cdate_ts); p += 8;
1676 SOFF_T(p,0,file_size); p += 8;
1677 SOFF_T(p,0,allocation_size); p += 8;
1678 SIVAL(p,0,nt_extmode); p += 4;
1679 q = p; p += 4; /* q is placeholder for name length. */
1681 unsigned int ea_size = estimate_ea_size(conn, NULL,
1682 smb_fname->base_name);
1683 SIVAL(p,0,ea_size); /* Extended attributes */
1686 /* Clear the short name buffer. This is
1687 * IMPORTANT as not doing so will trigger
1688 * a Win2k client bug. JRA.
1690 if (!was_8_3 && check_mangled_names) {
1691 char mangled_name[13]; /* mangled 8.3 name. */
1692 if (!name_to_8_3(fname,mangled_name,True,
1694 /* Error - mangle failed ! */
1695 memset(mangled_name,'\0',12);
1697 mangled_name[12] = 0;
1698 len = srvstr_push(base_data, flags2,
1699 p+2, mangled_name, 24,
1700 STR_UPPER|STR_UNICODE);
1702 memset(p + 2 + len,'\0',24 - len);
1709 len = srvstr_push(base_data, flags2, p,
1710 fname, PTR_DIFF(end_data, p),
1711 STR_TERMINATE_ASCII);
1715 len = PTR_DIFF(p, pdata);
1716 pad = (len + (align-1)) & ~(align-1);
1718 * offset to the next entry, the caller
1719 * will overwrite it for the last entry
1720 * that's why we always include the padding
1724 * set padding to zero
1727 memset(p, 0, pad - len);
1734 case SMB_FIND_FILE_DIRECTORY_INFO:
1735 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1737 SIVAL(p,0,reskey); p += 4;
1738 put_long_date_timespec(p,create_date_ts); p += 8;
1739 put_long_date_timespec(p,adate_ts); p += 8;
1740 put_long_date_timespec(p,mdate_ts); p += 8;
1741 put_long_date_timespec(p,cdate_ts); p += 8;
1742 SOFF_T(p,0,file_size); p += 8;
1743 SOFF_T(p,0,allocation_size); p += 8;
1744 SIVAL(p,0,nt_extmode); p += 4;
1745 len = srvstr_push(base_data, flags2,
1746 p + 4, fname, PTR_DIFF(end_data, p+4),
1747 STR_TERMINATE_ASCII);
1751 len = PTR_DIFF(p, pdata);
1752 pad = (len + (align-1)) & ~(align-1);
1754 * offset to the next entry, the caller
1755 * will overwrite it for the last entry
1756 * that's why we always include the padding
1760 * set padding to zero
1763 memset(p, 0, pad - len);
1770 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
1771 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1773 SIVAL(p,0,reskey); p += 4;
1774 put_long_date_timespec(p,create_date_ts); p += 8;
1775 put_long_date_timespec(p,adate_ts); p += 8;
1776 put_long_date_timespec(p,mdate_ts); p += 8;
1777 put_long_date_timespec(p,cdate_ts); p += 8;
1778 SOFF_T(p,0,file_size); p += 8;
1779 SOFF_T(p,0,allocation_size); p += 8;
1780 SIVAL(p,0,nt_extmode); p += 4;
1781 q = p; p += 4; /* q is placeholder for name length. */
1783 unsigned int ea_size = estimate_ea_size(conn, NULL,
1784 smb_fname->base_name);
1785 SIVAL(p,0,ea_size); /* Extended attributes */
1788 len = srvstr_push(base_data, flags2, p,
1789 fname, PTR_DIFF(end_data, p),
1790 STR_TERMINATE_ASCII);
1794 len = PTR_DIFF(p, pdata);
1795 pad = (len + (align-1)) & ~(align-1);
1797 * offset to the next entry, the caller
1798 * will overwrite it for the last entry
1799 * that's why we always include the padding
1803 * set padding to zero
1806 memset(p, 0, pad - len);
1813 case SMB_FIND_FILE_NAMES_INFO:
1814 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1816 SIVAL(p,0,reskey); p += 4;
1818 /* this must *not* be null terminated or w2k gets in a loop trying to set an
1819 acl on a dir (tridge) */
1820 len = srvstr_push(base_data, flags2, p,
1821 fname, PTR_DIFF(end_data, p),
1822 STR_TERMINATE_ASCII);
1826 len = PTR_DIFF(p, pdata);
1827 pad = (len + (align-1)) & ~(align-1);
1829 * offset to the next entry, the caller
1830 * will overwrite it for the last entry
1831 * that's why we always include the padding
1835 * set padding to zero
1838 memset(p, 0, pad - len);
1845 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
1846 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1848 SIVAL(p,0,reskey); p += 4;
1849 put_long_date_timespec(p,create_date_ts); p += 8;
1850 put_long_date_timespec(p,adate_ts); p += 8;
1851 put_long_date_timespec(p,mdate_ts); p += 8;
1852 put_long_date_timespec(p,cdate_ts); p += 8;
1853 SOFF_T(p,0,file_size); p += 8;
1854 SOFF_T(p,0,allocation_size); p += 8;
1855 SIVAL(p,0,nt_extmode); p += 4;
1856 q = p; p += 4; /* q is placeholder for name length. */
1858 unsigned int ea_size = estimate_ea_size(conn, NULL,
1859 smb_fname->base_name);
1860 SIVAL(p,0,ea_size); /* Extended attributes */
1863 SIVAL(p,0,0); p += 4; /* Unknown - reserved ? */
1864 SIVAL(p,0,smb_fname->st.st_ex_ino); p += 4; /* FileIndexLow */
1865 SIVAL(p,0,smb_fname->st.st_ex_dev); p += 4; /* FileIndexHigh */
1866 len = srvstr_push(base_data, flags2, p,
1867 fname, PTR_DIFF(end_data, p),
1868 STR_TERMINATE_ASCII);
1872 len = PTR_DIFF(p, pdata);
1873 pad = (len + (align-1)) & ~(align-1);
1875 * offset to the next entry, the caller
1876 * will overwrite it for the last entry
1877 * that's why we always include the padding
1881 * set padding to zero
1884 memset(p, 0, pad - len);
1891 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
1892 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1893 was_8_3 = mangle_is_8_3(fname, True, conn->params);
1895 SIVAL(p,0,reskey); p += 4;
1896 put_long_date_timespec(p,create_date_ts); p += 8;
1897 put_long_date_timespec(p,adate_ts); p += 8;
1898 put_long_date_timespec(p,mdate_ts); p += 8;
1899 put_long_date_timespec(p,cdate_ts); p += 8;
1900 SOFF_T(p,0,file_size); p += 8;
1901 SOFF_T(p,0,allocation_size); p += 8;
1902 SIVAL(p,0,nt_extmode); p += 4;
1903 q = p; p += 4; /* q is placeholder for name length */
1905 unsigned int ea_size = estimate_ea_size(conn, NULL,
1906 smb_fname->base_name);
1907 SIVAL(p,0,ea_size); /* Extended attributes */
1910 /* Clear the short name buffer. This is
1911 * IMPORTANT as not doing so will trigger
1912 * a Win2k client bug. JRA.
1914 if (!was_8_3 && check_mangled_names) {
1915 char mangled_name[13]; /* mangled 8.3 name. */
1916 if (!name_to_8_3(fname,mangled_name,True,
1918 /* Error - mangle failed ! */
1919 memset(mangled_name,'\0',12);
1921 mangled_name[12] = 0;
1922 len = srvstr_push(base_data, flags2,
1923 p+2, mangled_name, 24,
1924 STR_UPPER|STR_UNICODE);
1927 memset(p + 2 + len,'\0',24 - len);
1934 SSVAL(p,0,0); p += 2; /* Reserved ? */
1935 SIVAL(p,0,smb_fname->st.st_ex_ino); p += 4; /* FileIndexLow */
1936 SIVAL(p,0,smb_fname->st.st_ex_dev); p += 4; /* FileIndexHigh */
1937 len = srvstr_push(base_data, flags2, p,
1938 fname, PTR_DIFF(end_data, p),
1939 STR_TERMINATE_ASCII);
1943 len = PTR_DIFF(p, pdata);
1944 pad = (len + (align-1)) & ~(align-1);
1946 * offset to the next entry, the caller
1947 * will overwrite it for the last entry
1948 * that's why we always include the padding
1952 * set padding to zero
1955 memset(p, 0, pad - len);
1962 /* CIFS UNIX Extension. */
1964 case SMB_FIND_FILE_UNIX:
1965 case SMB_FIND_FILE_UNIX_INFO2:
1967 SIVAL(p,0,reskey); p+= 4; /* Used for continuing search. */
1969 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1971 if (info_level == SMB_FIND_FILE_UNIX) {
1972 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX\n"));
1973 p = store_file_unix_basic(conn, p,
1974 NULL, &smb_fname->st);
1975 len = srvstr_push(base_data, flags2, p,
1976 fname, PTR_DIFF(end_data, p),
1979 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
1980 p = store_file_unix_basic_info2(conn, p,
1981 NULL, &smb_fname->st);
1984 len = srvstr_push(base_data, flags2, p, fname,
1985 PTR_DIFF(end_data, p), 0);
1986 SIVAL(nameptr, 0, len);
1991 len = PTR_DIFF(p, pdata);
1992 pad = (len + (align-1)) & ~(align-1);
1994 * offset to the next entry, the caller
1995 * will overwrite it for the last entry
1996 * that's why we always include the padding
2000 * set padding to zero
2003 memset(p, 0, pad - len);
2008 /* End of SMB_QUERY_FILE_UNIX_BASIC */
2016 if (PTR_DIFF(p,pdata) > space_remaining) {
2017 *out_of_space = true;
2018 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
2019 return false; /* Not finished - just out of space */
2022 /* Setup the last entry pointer, as an offset from base_data */
2023 *last_entry_off = PTR_DIFF(last_entry_ptr,base_data);
2024 /* Advance the data pointer to the next slot */
2030 bool smbd_dirptr_lanman2_entry(TALLOC_CTX *ctx,
2031 connection_struct *conn,
2032 struct dptr_struct *dirptr,
2034 const char *path_mask,
2037 int requires_resume_key,
2045 int space_remaining,
2047 bool *got_exact_match,
2048 int *_last_entry_off,
2049 struct ea_list *name_list)
2052 const char *mask = NULL;
2053 long prev_dirpos = 0;
2056 struct smb_filename *smb_fname = NULL;
2057 struct smbd_dirptr_lanman2_state state;
2059 uint64_t last_entry_off = 0;
2063 state.info_level = info_level;
2064 state.check_mangled_names = lp_manglednames(conn->params);
2065 state.has_wild = dptr_has_wild(dirptr);
2066 state.got_exact_match = false;
2068 *out_of_space = false;
2069 *got_exact_match = false;
2071 p = strrchr_m(path_mask,'/');
2082 ok = smbd_dirptr_get_entry(ctx,
2088 smbd_dirptr_lanman2_match_fn,
2089 smbd_dirptr_lanman2_mode_fn,
2099 *got_exact_match = state.got_exact_match;
2101 ok = smbd_marshall_dir_entry(ctx,
2106 state.check_mangled_names,
2107 requires_resume_key,
2120 TALLOC_FREE(smb_fname);
2121 if (*out_of_space) {
2122 dptr_SeekDir(dirptr, prev_dirpos);
2129 *_last_entry_off = last_entry_off;
2133 static bool get_lanman2_dir_entry(TALLOC_CTX *ctx,
2134 connection_struct *conn,
2135 struct dptr_struct *dirptr,
2137 const char *path_mask,
2140 int requires_resume_key,
2146 int space_remaining,
2148 bool *got_exact_match,
2149 int *last_entry_off,
2150 struct ea_list *name_list)
2152 bool resume_key = false;
2153 const uint8_t align = 4;
2154 const bool do_pad = true;
2156 if (requires_resume_key) {
2160 return smbd_dirptr_lanman2_entry(ctx, conn, dirptr, flags2,
2161 path_mask, dirtype, info_level,
2162 resume_key, dont_descend, ask_sharemode,
2164 ppdata, base_data, end_data,
2166 out_of_space, got_exact_match,
2167 last_entry_off, name_list);
2170 /****************************************************************************
2171 Reply to a TRANS2_FINDFIRST.
2172 ****************************************************************************/
2174 static void call_trans2findfirst(connection_struct *conn,
2175 struct smb_request *req,
2176 char **pparams, int total_params,
2177 char **ppdata, int total_data,
2178 unsigned int max_data_bytes)
2180 /* We must be careful here that we don't return more than the
2181 allowed number of data bytes. If this means returning fewer than
2182 maxentries then so be it. We assume that the redirector has
2183 enough room for the fixed number of parameter bytes it has
2185 struct smb_filename *smb_dname = NULL;
2186 char *params = *pparams;
2187 char *pdata = *ppdata;
2191 uint16 findfirst_flags;
2192 bool close_after_first;
2194 bool requires_resume_key;
2196 char *directory = NULL;
2199 int last_entry_off=0;
2203 bool finished = False;
2204 bool dont_descend = False;
2205 bool out_of_space = False;
2206 int space_remaining;
2207 bool mask_contains_wcard = False;
2208 struct ea_list *ea_list = NULL;
2209 NTSTATUS ntstatus = NT_STATUS_OK;
2210 bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2211 TALLOC_CTX *ctx = talloc_tos();
2212 struct dptr_struct *dirptr = NULL;
2213 struct smbd_server_connection *sconn = smbd_server_conn;
2215 if (total_params < 13) {
2216 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2220 dirtype = SVAL(params,0);
2221 maxentries = SVAL(params,2);
2222 findfirst_flags = SVAL(params,4);
2223 close_after_first = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE);
2224 close_if_end = (findfirst_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2225 requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2226 info_level = SVAL(params,6);
2228 DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
2229 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
2230 (unsigned int)dirtype, maxentries, close_after_first, close_if_end, requires_resume_key,
2231 info_level, max_data_bytes));
2234 /* W2K3 seems to treat zero as 1. */
2238 switch (info_level) {
2239 case SMB_FIND_INFO_STANDARD:
2240 case SMB_FIND_EA_SIZE:
2241 case SMB_FIND_EA_LIST:
2242 case SMB_FIND_FILE_DIRECTORY_INFO:
2243 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2244 case SMB_FIND_FILE_NAMES_INFO:
2245 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2246 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2247 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2249 case SMB_FIND_FILE_UNIX:
2250 case SMB_FIND_FILE_UNIX_INFO2:
2251 /* Always use filesystem for UNIX mtime query. */
2252 ask_sharemode = false;
2253 if (!lp_unix_extensions()) {
2254 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2259 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2263 srvstr_get_path_wcard(ctx, params, req->flags2, &directory,
2264 params+12, total_params - 12,
2265 STR_TERMINATE, &ntstatus, &mask_contains_wcard);
2266 if (!NT_STATUS_IS_OK(ntstatus)) {
2267 reply_nterror(req, ntstatus);
2271 ntstatus = filename_convert(ctx, conn,
2272 req->flags2 & FLAGS2_DFS_PATHNAMES,
2275 UCF_ALWAYS_ALLOW_WCARD_LCOMP),
2276 &mask_contains_wcard,
2278 if (!NT_STATUS_IS_OK(ntstatus)) {
2279 if (NT_STATUS_EQUAL(ntstatus,NT_STATUS_PATH_NOT_COVERED)) {
2280 reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
2281 ERRSRV, ERRbadpath);
2284 reply_nterror(req, ntstatus);
2288 mask = smb_dname->original_lcomp;
2290 directory = smb_dname->base_name;
2292 p = strrchr_m(directory,'/');
2294 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
2295 if((directory[0] == '.') && (directory[1] == '\0')) {
2296 mask = talloc_strdup(ctx,"*");
2298 reply_nterror(req, NT_STATUS_NO_MEMORY);
2301 mask_contains_wcard = True;
2303 directory = talloc_strdup(talloc_tos(), "./");
2305 reply_nterror(req, NT_STATUS_NO_MEMORY);
2312 DEBUG(5,("dir=%s, mask = %s\n",directory, mask));
2314 if (info_level == SMB_FIND_EA_LIST) {
2317 if (total_data < 4) {
2318 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2322 ea_size = IVAL(pdata,0);
2323 if (ea_size != total_data) {
2324 DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
2325 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2326 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2330 if (!lp_ea_support(SNUM(conn))) {
2331 reply_doserror(req, ERRDOS, ERReasnotsupported);
2335 /* Pull out the list of names. */
2336 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2338 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2343 *ppdata = (char *)SMB_REALLOC(
2344 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2345 if(*ppdata == NULL ) {
2346 reply_nterror(req, NT_STATUS_NO_MEMORY);
2350 data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2352 /* Realloc the params space */
2353 *pparams = (char *)SMB_REALLOC(*pparams, 10);
2354 if (*pparams == NULL) {
2355 reply_nterror(req, NT_STATUS_NO_MEMORY);
2360 /* Save the wildcard match and attribs we are using on this directory -
2361 needed as lanman2 assumes these are being saved between calls */
2363 ntstatus = dptr_create(conn,
2369 mask_contains_wcard,
2373 if (!NT_STATUS_IS_OK(ntstatus)) {
2374 reply_nterror(req, ntstatus);
2378 dptr_num = dptr_dnum(dirptr);
2379 DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num, mask, dirtype));
2381 /* Initialize per TRANS2_FIND_FIRST operation data */
2382 dptr_init_search_op(dirptr);
2384 /* We don't need to check for VOL here as this is returned by
2385 a different TRANS2 call. */
2387 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2388 directory,lp_dontdescend(SNUM(conn))));
2389 if (in_list(directory,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2390 dont_descend = True;
2393 space_remaining = max_data_bytes;
2394 out_of_space = False;
2396 for (i=0;(i<maxentries) && !finished && !out_of_space;i++) {
2397 bool got_exact_match = False;
2399 /* this is a heuristic to avoid seeking the dirptr except when
2400 absolutely necessary. It allows for a filename of about 40 chars */
2401 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2402 out_of_space = True;
2405 finished = !get_lanman2_dir_entry(ctx,
2409 mask,dirtype,info_level,
2410 requires_resume_key,dont_descend,
2413 space_remaining, &out_of_space,
2415 &last_entry_off, ea_list);
2418 if (finished && out_of_space)
2421 if (!finished && !out_of_space)
2425 * As an optimisation if we know we aren't looking
2426 * for a wildcard name (ie. the name matches the wildcard exactly)
2427 * then we can finish on any (first) match.
2428 * This speeds up large directory searches. JRA.
2434 /* Ensure space_remaining never goes -ve. */
2435 if (PTR_DIFF(p,pdata) > max_data_bytes) {
2436 space_remaining = 0;
2437 out_of_space = true;
2439 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2443 /* Check if we can close the dirptr */
2444 if(close_after_first || (finished && close_if_end)) {
2445 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num));
2446 dptr_close(sconn, &dptr_num);
2450 * If there are no matching entries we must return ERRDOS/ERRbadfile -
2451 * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2452 * the protocol level is less than NT1. Tested with smbclient. JRA.
2453 * This should fix the OS/2 client bug #2335.
2456 if(numentries == 0) {
2457 dptr_close(sconn, &dptr_num);
2458 if (Protocol < PROTOCOL_NT1) {
2459 reply_doserror(req, ERRDOS, ERRnofiles);
2462 reply_botherror(req, NT_STATUS_NO_SUCH_FILE,
2463 ERRDOS, ERRbadfile);
2468 /* At this point pdata points to numentries directory entries. */
2470 /* Set up the return parameter block */
2471 SSVAL(params,0,dptr_num);
2472 SSVAL(params,2,numentries);
2473 SSVAL(params,4,finished);
2474 SSVAL(params,6,0); /* Never an EA error */
2475 SSVAL(params,8,last_entry_off);
2477 send_trans2_replies(conn, req, params, 10, pdata, PTR_DIFF(p,pdata),
2480 if ((! *directory) && dptr_path(sconn, dptr_num)) {
2481 directory = talloc_strdup(talloc_tos(),dptr_path(sconn, dptr_num));
2483 reply_nterror(req, NT_STATUS_NO_MEMORY);
2487 DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2488 smb_fn_name(req->cmd),
2489 mask, directory, dirtype, numentries ) );
2492 * Force a name mangle here to ensure that the
2493 * mask as an 8.3 name is top of the mangled cache.
2494 * The reasons for this are subtle. Don't remove
2495 * this code unless you know what you are doing
2496 * (see PR#13758). JRA.
2499 if(!mangle_is_8_3_wildcards( mask, False, conn->params)) {
2500 char mangled_name[13];
2501 name_to_8_3(mask, mangled_name, True, conn->params);
2504 TALLOC_FREE(smb_dname);
2508 /****************************************************************************
2509 Reply to a TRANS2_FINDNEXT.
2510 ****************************************************************************/
2512 static void call_trans2findnext(connection_struct *conn,
2513 struct smb_request *req,
2514 char **pparams, int total_params,
2515 char **ppdata, int total_data,
2516 unsigned int max_data_bytes)
2518 /* We must be careful here that we don't return more than the
2519 allowed number of data bytes. If this means returning fewer than
2520 maxentries then so be it. We assume that the redirector has
2521 enough room for the fixed number of parameter bytes it has
2523 char *params = *pparams;
2524 char *pdata = *ppdata;
2530 uint16 findnext_flags;
2531 bool close_after_request;
2533 bool requires_resume_key;
2535 bool mask_contains_wcard = False;
2536 char *resume_name = NULL;
2537 const char *mask = NULL;
2538 const char *directory = NULL;
2542 int i, last_entry_off=0;
2543 bool finished = False;
2544 bool dont_descend = False;
2545 bool out_of_space = False;
2546 int space_remaining;
2547 struct ea_list *ea_list = NULL;
2548 NTSTATUS ntstatus = NT_STATUS_OK;
2549 bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
2550 TALLOC_CTX *ctx = talloc_tos();
2551 struct dptr_struct *dirptr;
2552 struct smbd_server_connection *sconn = smbd_server_conn;
2554 if (total_params < 13) {
2555 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2559 dptr_num = SVAL(params,0);
2560 maxentries = SVAL(params,2);
2561 info_level = SVAL(params,4);
2562 resume_key = IVAL(params,6);
2563 findnext_flags = SVAL(params,10);
2564 close_after_request = (findnext_flags & FLAG_TRANS2_FIND_CLOSE);
2565 close_if_end = (findnext_flags & FLAG_TRANS2_FIND_CLOSE_IF_END);
2566 requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
2567 continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
2569 srvstr_get_path_wcard(ctx, params, req->flags2, &resume_name,
2571 total_params - 12, STR_TERMINATE, &ntstatus,
2572 &mask_contains_wcard);
2573 if (!NT_STATUS_IS_OK(ntstatus)) {
2574 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2575 complain (it thinks we're asking for the directory above the shared
2576 path or an invalid name). Catch this as the resume name is only compared, never used in
2577 a file access. JRA. */
2578 srvstr_pull_talloc(ctx, params, req->flags2,
2579 &resume_name, params+12,
2583 if (!resume_name || !(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
2584 reply_nterror(req, ntstatus);
2589 DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2590 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2591 resume_key = %d resume name = %s continue=%d level = %d\n",
2592 dptr_num, max_data_bytes, maxentries, close_after_request, close_if_end,
2593 requires_resume_key, resume_key, resume_name, continue_bit, info_level));
2596 /* W2K3 seems to treat zero as 1. */
2600 switch (info_level) {
2601 case SMB_FIND_INFO_STANDARD:
2602 case SMB_FIND_EA_SIZE:
2603 case SMB_FIND_EA_LIST:
2604 case SMB_FIND_FILE_DIRECTORY_INFO:
2605 case SMB_FIND_FILE_FULL_DIRECTORY_INFO:
2606 case SMB_FIND_FILE_NAMES_INFO:
2607 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO:
2608 case SMB_FIND_ID_FULL_DIRECTORY_INFO:
2609 case SMB_FIND_ID_BOTH_DIRECTORY_INFO:
2611 case SMB_FIND_FILE_UNIX:
2612 case SMB_FIND_FILE_UNIX_INFO2:
2613 /* Always use filesystem for UNIX mtime query. */
2614 ask_sharemode = false;
2615 if (!lp_unix_extensions()) {
2616 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2621 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
2625 if (info_level == SMB_FIND_EA_LIST) {
2628 if (total_data < 4) {
2629 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2633 ea_size = IVAL(pdata,0);
2634 if (ea_size != total_data) {
2635 DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2636 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
2637 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2641 if (!lp_ea_support(SNUM(conn))) {
2642 reply_doserror(req, ERRDOS, ERReasnotsupported);
2646 /* Pull out the list of names. */
2647 ea_list = read_ea_name_list(ctx, pdata + 4, ea_size - 4);
2649 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
2654 *ppdata = (char *)SMB_REALLOC(
2655 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2656 if(*ppdata == NULL) {
2657 reply_nterror(req, NT_STATUS_NO_MEMORY);
2662 data_end = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2664 /* Realloc the params space */
2665 *pparams = (char *)SMB_REALLOC(*pparams, 6*SIZEOFWORD);
2666 if(*pparams == NULL ) {
2667 reply_nterror(req, NT_STATUS_NO_MEMORY);
2673 /* Check that the dptr is valid */
2674 if(!(dirptr = dptr_fetch_lanman2(sconn, dptr_num))) {
2675 reply_doserror(req, ERRDOS, ERRnofiles);
2679 directory = dptr_path(sconn, dptr_num);
2681 /* Get the wildcard mask from the dptr */
2682 if((p = dptr_wcard(sconn, dptr_num))== NULL) {
2683 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num));
2684 reply_doserror(req, ERRDOS, ERRnofiles);
2690 /* Get the attr mask from the dptr */
2691 dirtype = dptr_attr(sconn, dptr_num);
2693 DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2694 dptr_num, mask, dirtype,
2696 dptr_TellDir(dirptr)));
2698 /* Initialize per TRANS2_FIND_NEXT operation data */
2699 dptr_init_search_op(dirptr);
2701 /* We don't need to check for VOL here as this is returned by
2702 a different TRANS2 call. */
2704 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2705 directory,lp_dontdescend(SNUM(conn))));
2706 if (in_list(directory,lp_dontdescend(SNUM(conn)),conn->case_sensitive))
2707 dont_descend = True;
2710 space_remaining = max_data_bytes;
2711 out_of_space = False;
2714 * Seek to the correct position. We no longer use the resume key but
2715 * depend on the last file name instead.
2718 if(*resume_name && !continue_bit) {
2721 long current_pos = 0;
2723 * Remember, name_to_8_3 is called by
2724 * get_lanman2_dir_entry(), so the resume name
2725 * could be mangled. Ensure we check the unmangled name.
2728 if (mangle_is_mangled(resume_name, conn->params)) {
2729 char *new_resume_name = NULL;
2730 mangle_lookup_name_from_8_3(ctx,
2734 if (new_resume_name) {
2735 resume_name = new_resume_name;
2740 * Fix for NT redirector problem triggered by resume key indexes
2741 * changing between directory scans. We now return a resume key of 0
2742 * and instead look for the filename to continue from (also given
2743 * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2744 * findfirst/findnext (as is usual) then the directory pointer
2745 * should already be at the correct place.
2748 finished = !dptr_SearchDir(dirptr, resume_name, ¤t_pos, &st);
2749 } /* end if resume_name && !continue_bit */
2751 for (i=0;(i<(int)maxentries) && !finished && !out_of_space ;i++) {
2752 bool got_exact_match = False;
2754 /* this is a heuristic to avoid seeking the dirptr except when
2755 absolutely necessary. It allows for a filename of about 40 chars */
2756 if (space_remaining < DIRLEN_GUESS && numentries > 0) {
2757 out_of_space = True;
2760 finished = !get_lanman2_dir_entry(ctx,
2764 mask,dirtype,info_level,
2765 requires_resume_key,dont_descend,
2768 space_remaining, &out_of_space,
2770 &last_entry_off, ea_list);
2773 if (finished && out_of_space)
2776 if (!finished && !out_of_space)
2780 * As an optimisation if we know we aren't looking
2781 * for a wildcard name (ie. the name matches the wildcard exactly)
2782 * then we can finish on any (first) match.
2783 * This speeds up large directory searches. JRA.
2789 space_remaining = max_data_bytes - PTR_DIFF(p,pdata);
2792 DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2793 smb_fn_name(req->cmd),
2794 mask, directory, dirtype, numentries ) );
2796 /* Check if we can close the dirptr */
2797 if(close_after_request || (finished && close_if_end)) {
2798 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num));
2799 dptr_close(sconn, &dptr_num); /* This frees up the saved mask */
2802 /* Set up the return parameter block */
2803 SSVAL(params,0,numentries);
2804 SSVAL(params,2,finished);
2805 SSVAL(params,4,0); /* Never an EA error */
2806 SSVAL(params,6,last_entry_off);
2808 send_trans2_replies(conn, req, params, 8, pdata, PTR_DIFF(p,pdata),
2814 unsigned char *create_volume_objectid(connection_struct *conn, unsigned char objid[16])
2816 E_md4hash(lp_servicename(SNUM(conn)),objid);
2820 static void samba_extended_info_version(struct smb_extended_info *extended_info)
2822 SMB_ASSERT(extended_info != NULL);
2824 extended_info->samba_magic = SAMBA_EXTENDED_INFO_MAGIC;
2825 extended_info->samba_version = ((SAMBA_VERSION_MAJOR & 0xff) << 24)
2826 | ((SAMBA_VERSION_MINOR & 0xff) << 16)
2827 | ((SAMBA_VERSION_RELEASE & 0xff) << 8);
2828 #ifdef SAMBA_VERSION_REVISION
2829 extended_info->samba_version |= (tolower(*SAMBA_VERSION_REVISION) - 'a' + 1) & 0xff;
2831 extended_info->samba_subversion = 0;
2832 #ifdef SAMBA_VERSION_RC_RELEASE
2833 extended_info->samba_subversion |= (SAMBA_VERSION_RC_RELEASE & 0xff) << 24;
2835 #ifdef SAMBA_VERSION_PRE_RELEASE
2836 extended_info->samba_subversion |= (SAMBA_VERSION_PRE_RELEASE & 0xff) << 16;
2839 #ifdef SAMBA_VERSION_VENDOR_PATCH
2840 extended_info->samba_subversion |= (SAMBA_VERSION_VENDOR_PATCH & 0xffff);
2842 extended_info->samba_gitcommitdate = 0;
2843 #ifdef SAMBA_VERSION_GIT_COMMIT_TIME
2844 unix_to_nt_time(&extended_info->samba_gitcommitdate, SAMBA_VERSION_GIT_COMMIT_TIME);
2847 memset(extended_info->samba_version_string, 0,
2848 sizeof(extended_info->samba_version_string));
2850 snprintf (extended_info->samba_version_string,
2851 sizeof(extended_info->samba_version_string),
2852 "%s", samba_version_string());
2855 NTSTATUS smbd_do_qfsinfo(connection_struct *conn,
2856 TALLOC_CTX *mem_ctx,
2857 uint16_t info_level,
2859 unsigned int max_data_bytes,
2863 char *pdata, *end_data;
2864 int data_len = 0, len;
2865 const char *vname = volume_label(SNUM(conn));
2866 int snum = SNUM(conn);
2867 char *fstype = lp_fstype(SNUM(conn));
2868 uint32 additional_flags = 0;
2869 struct smb_filename *smb_fname_dot = NULL;
2874 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
2875 DEBUG(0,("smbd_do_qfsinfo: not an allowed "
2876 "info level (0x%x) on IPC$.\n",
2877 (unsigned int)info_level));
2878 return NT_STATUS_ACCESS_DENIED;
2882 DEBUG(3,("smbd_do_qfsinfo: level = %d\n", info_level));
2884 status = create_synthetic_smb_fname(talloc_tos(), ".", NULL, NULL,
2886 if (!NT_STATUS_IS_OK(status)) {
2890 if(SMB_VFS_STAT(conn, smb_fname_dot) != 0) {
2891 DEBUG(2,("stat of . failed (%s)\n", strerror(errno)));
2892 TALLOC_FREE(smb_fname_dot);
2893 return map_nt_error_from_unix(errno);
2896 st = smb_fname_dot->st;
2897 TALLOC_FREE(smb_fname_dot);
2899 *ppdata = (char *)SMB_REALLOC(
2900 *ppdata, max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2901 if (*ppdata == NULL) {
2902 return NT_STATUS_NO_MEMORY;
2906 memset((char *)pdata,'\0',max_data_bytes + DIR_ENTRY_SAFETY_MARGIN);
2907 end_data = pdata + max_data_bytes + DIR_ENTRY_SAFETY_MARGIN - 1;
2909 switch (info_level) {
2910 case SMB_INFO_ALLOCATION:
2912 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
2914 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
2915 return map_nt_error_from_unix(errno);
2918 block_size = lp_block_size(snum);
2919 if (bsize < block_size) {
2920 uint64_t factor = block_size/bsize;
2925 if (bsize > block_size) {
2926 uint64_t factor = bsize/block_size;
2931 bytes_per_sector = 512;
2932 sectors_per_unit = bsize/bytes_per_sector;
2934 DEBUG(5,("smbd_do_qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2935 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st.st_ex_dev, (unsigned int)bsize, (unsigned int)sectors_per_unit,
2936 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
2938 SIVAL(pdata,l1_idFileSystem,st.st_ex_dev);
2939 SIVAL(pdata,l1_cSectorUnit,sectors_per_unit);
2940 SIVAL(pdata,l1_cUnit,dsize);
2941 SIVAL(pdata,l1_cUnitAvail,dfree);
2942 SSVAL(pdata,l1_cbSector,bytes_per_sector);
2946 case SMB_INFO_VOLUME:
2947 /* Return volume name */
2949 * Add volume serial number - hash of a combination of
2950 * the called hostname and the service name.
2952 SIVAL(pdata,0,str_checksum(lp_servicename(snum)) ^ (str_checksum(get_local_machine_name())<<16) );
2954 * Win2k3 and previous mess this up by sending a name length
2955 * one byte short. I believe only older clients (OS/2 Win9x) use
2956 * this call so try fixing this by adding a terminating null to
2957 * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2961 pdata+l2_vol_szVolLabel, vname,
2962 PTR_DIFF(end_data, pdata+l2_vol_szVolLabel),
2963 STR_NOALIGN|STR_TERMINATE);
2964 SCVAL(pdata,l2_vol_cch,len);
2965 data_len = l2_vol_szVolLabel + len;
2966 DEBUG(5,("smbd_do_qfsinfo : time = %x, namelen = %d, name = %s\n",
2967 (unsigned)convert_timespec_to_time_t(st.st_ex_ctime),
2971 case SMB_QUERY_FS_ATTRIBUTE_INFO:
2972 case SMB_FS_ATTRIBUTE_INFORMATION:
2974 additional_flags = 0;
2975 #if defined(HAVE_SYS_QUOTAS)
2976 additional_flags |= FILE_VOLUME_QUOTAS;
2979 if(lp_nt_acl_support(SNUM(conn))) {
2980 additional_flags |= FILE_PERSISTENT_ACLS;
2983 /* Capabilities are filled in at connection time through STATVFS call */
2984 additional_flags |= conn->fs_capabilities;
2986 SIVAL(pdata,0,FILE_CASE_PRESERVED_NAMES|FILE_CASE_SENSITIVE_SEARCH|
2987 FILE_SUPPORTS_OBJECT_IDS|FILE_UNICODE_ON_DISK|
2988 additional_flags); /* FS ATTRIBUTES */
2990 SIVAL(pdata,4,255); /* Max filename component length */
2991 /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2992 and will think we can't do long filenames */
2993 len = srvstr_push(pdata, flags2, pdata+12, fstype,
2994 PTR_DIFF(end_data, pdata+12),
2997 data_len = 12 + len;
3000 case SMB_QUERY_FS_LABEL_INFO:
3001 case SMB_FS_LABEL_INFORMATION:
3002 len = srvstr_push(pdata, flags2, pdata+4, vname,
3003 PTR_DIFF(end_data, pdata+4), 0);
3008 case SMB_QUERY_FS_VOLUME_INFO:
3009 case SMB_FS_VOLUME_INFORMATION:
3012 * Add volume serial number - hash of a combination of
3013 * the called hostname and the service name.
3015 SIVAL(pdata,8,str_checksum(lp_servicename(snum)) ^
3016 (str_checksum(get_local_machine_name())<<16));
3018 /* Max label len is 32 characters. */
3019 len = srvstr_push(pdata, flags2, pdata+18, vname,
3020 PTR_DIFF(end_data, pdata+18),
3022 SIVAL(pdata,12,len);
3025 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
3026 (int)strlen(vname),vname, lp_servicename(snum)));
3029 case SMB_QUERY_FS_SIZE_INFO:
3030 case SMB_FS_SIZE_INFORMATION:
3032 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3034 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3035 return map_nt_error_from_unix(errno);
3037 block_size = lp_block_size(snum);
3038 if (bsize < block_size) {
3039 uint64_t factor = block_size/bsize;
3044 if (bsize > block_size) {
3045 uint64_t factor = bsize/block_size;
3050 bytes_per_sector = 512;
3051 sectors_per_unit = bsize/bytes_per_sector;
3052 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3053 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3054 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3055 SBIG_UINT(pdata,0,dsize);
3056 SBIG_UINT(pdata,8,dfree);
3057 SIVAL(pdata,16,sectors_per_unit);
3058 SIVAL(pdata,20,bytes_per_sector);
3062 case SMB_FS_FULL_SIZE_INFORMATION:
3064 uint64_t dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
3066 if (get_dfree_info(conn,".",False,&bsize,&dfree,&dsize) == (uint64_t)-1) {
3067 return map_nt_error_from_unix(errno);
3069 block_size = lp_block_size(snum);
3070 if (bsize < block_size) {
3071 uint64_t factor = block_size/bsize;
3076 if (bsize > block_size) {
3077 uint64_t factor = bsize/block_size;
3082 bytes_per_sector = 512;
3083 sectors_per_unit = bsize/bytes_per_sector;
3084 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3085 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned int)sectors_per_unit,
3086 (unsigned int)bytes_per_sector, (unsigned int)dsize, (unsigned int)dfree));
3087 SBIG_UINT(pdata,0,dsize); /* Total Allocation units. */
3088 SBIG_UINT(pdata,8,dfree); /* Caller available allocation units. */
3089 SBIG_UINT(pdata,16,dfree); /* Actual available allocation units. */
3090 SIVAL(pdata,24,sectors_per_unit); /* Sectors per allocation unit. */
3091 SIVAL(pdata,28,bytes_per_sector); /* Bytes per sector. */
3095 case SMB_QUERY_FS_DEVICE_INFO:
3096 case SMB_FS_DEVICE_INFORMATION:
3098 SIVAL(pdata,0,0); /* dev type */
3099 SIVAL(pdata,4,0); /* characteristics */
3102 #ifdef HAVE_SYS_QUOTAS
3103 case SMB_FS_QUOTA_INFORMATION:
3105 * what we have to send --metze:
3107 * Unknown1: 24 NULL bytes
3108 * Soft Quota Treshold: 8 bytes seems like uint64_t or so
3109 * Hard Quota Limit: 8 bytes seems like uint64_t or so
3110 * Quota Flags: 2 byte :
3111 * Unknown3: 6 NULL bytes
3115 * details for Quota Flags:
3117 * 0x0020 Log Limit: log if the user exceeds his Hard Quota
3118 * 0x0010 Log Warn: log if the user exceeds his Soft Quota
3119 * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
3120 * 0x0001 Enable Quotas: enable quota for this fs
3124 /* we need to fake up a fsp here,
3125 * because its not send in this call
3128 SMB_NTQUOTA_STRUCT quotas;
3131 ZERO_STRUCT(quotas);
3137 if (conn->server_info->utok.uid != sec_initial_uid()) {
3138 DEBUG(0,("set_user_quota: access_denied "
3139 "service [%s] user [%s]\n",
3140 lp_servicename(SNUM(conn)),
3141 conn->server_info->unix_name));
3142 return NT_STATUS_ACCESS_DENIED;
3145 if (vfs_get_ntquota(&fsp, SMB_USER_FS_QUOTA_TYPE, NULL, "as)!=0) {
3146 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3147 return map_nt_error_from_unix(errno);
3152 DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",
3153 lp_servicename(SNUM(conn))));
3155 /* Unknown1 24 NULL bytes*/
3156 SBIG_UINT(pdata,0,(uint64_t)0);
3157 SBIG_UINT(pdata,8,(uint64_t)0);
3158 SBIG_UINT(pdata,16,(uint64_t)0);
3160 /* Default Soft Quota 8 bytes */
3161 SBIG_UINT(pdata,24,quotas.softlim);
3163 /* Default Hard Quota 8 bytes */
3164 SBIG_UINT(pdata,32,quotas.hardlim);
3166 /* Quota flag 2 bytes */
3167 SSVAL(pdata,40,quotas.qflags);
3169 /* Unknown3 6 NULL bytes */
3175 #endif /* HAVE_SYS_QUOTAS */
3176 case SMB_FS_OBJECTID_INFORMATION:
3178 unsigned char objid[16];
3179 struct smb_extended_info extended_info;
3180 memcpy(pdata,create_volume_objectid(conn, objid),16);
3181 samba_extended_info_version (&extended_info);
3182 SIVAL(pdata,16,extended_info.samba_magic);
3183 SIVAL(pdata,20,extended_info.samba_version);
3184 SIVAL(pdata,24,extended_info.samba_subversion);
3185 SBIG_UINT(pdata,28,extended_info.samba_gitcommitdate);
3186 memcpy(pdata+36,extended_info.samba_version_string,28);
3192 * Query the version and capabilities of the CIFS UNIX extensions
3196 case SMB_QUERY_CIFS_UNIX_INFO:
3198 bool large_write = lp_min_receive_file_size() &&
3199 !srv_is_signing_active(smbd_server_conn);
3200 bool large_read = !srv_is_signing_active(smbd_server_conn);
3201 int encrypt_caps = 0;
3203 if (!lp_unix_extensions()) {
3204 return NT_STATUS_INVALID_LEVEL;
3207 switch (conn->encrypt_level) {
3213 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP;
3216 encrypt_caps = CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP|
3217 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP;
3218 large_write = false;
3224 SSVAL(pdata,0,CIFS_UNIX_MAJOR_VERSION);
3225 SSVAL(pdata,2,CIFS_UNIX_MINOR_VERSION);
3227 /* We have POSIX ACLs, pathname, encryption,
3228 * large read/write, and locking capability. */
3230 SBIG_UINT(pdata,4,((uint64_t)(
3231 CIFS_UNIX_POSIX_ACLS_CAP|
3232 CIFS_UNIX_POSIX_PATHNAMES_CAP|
3233 CIFS_UNIX_FCNTL_LOCKS_CAP|
3234 CIFS_UNIX_EXTATTR_CAP|
3235 CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP|
3237 (large_read ? CIFS_UNIX_LARGE_READ_CAP : 0) |
3239 CIFS_UNIX_LARGE_WRITE_CAP : 0))));
3243 case SMB_QUERY_POSIX_FS_INFO:
3246 vfs_statvfs_struct svfs;
3248 if (!lp_unix_extensions()) {
3249 return NT_STATUS_INVALID_LEVEL;
3252 rc = SMB_VFS_STATVFS(conn, ".", &svfs);
3256 SIVAL(pdata,0,svfs.OptimalTransferSize);
3257 SIVAL(pdata,4,svfs.BlockSize);
3258 SBIG_UINT(pdata,8,svfs.TotalBlocks);
3259 SBIG_UINT(pdata,16,svfs.BlocksAvail);
3260 SBIG_UINT(pdata,24,svfs.UserBlocksAvail);
3261 SBIG_UINT(pdata,32,svfs.TotalFileNodes);
3262 SBIG_UINT(pdata,40,svfs.FreeFileNodes);
3263 SBIG_UINT(pdata,48,svfs.FsIdentifier);
3264 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
3266 } else if (rc == EOPNOTSUPP) {
3267 return NT_STATUS_INVALID_LEVEL;
3268 #endif /* EOPNOTSUPP */
3270 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3271 return NT_STATUS_DOS(ERRSRV, ERRerror);
3276 case SMB_QUERY_POSIX_WHOAMI:
3282 if (!lp_unix_extensions()) {
3283 return NT_STATUS_INVALID_LEVEL;
3286 if (max_data_bytes < 40) {
3287 return NT_STATUS_BUFFER_TOO_SMALL;
3290 /* We ARE guest if global_sid_Builtin_Guests is
3291 * in our list of SIDs.
3293 if (nt_token_check_sid(&global_sid_Builtin_Guests,
3294 conn->server_info->ptok)) {
3295 flags |= SMB_WHOAMI_GUEST;
3298 /* We are NOT guest if global_sid_Authenticated_Users
3299 * is in our list of SIDs.
3301 if (nt_token_check_sid(&global_sid_Authenticated_Users,
3302 conn->server_info->ptok)) {
3303 flags &= ~SMB_WHOAMI_GUEST;
3306 /* NOTE: 8 bytes for UID/GID, irrespective of native
3307 * platform size. This matches
3308 * SMB_QUERY_FILE_UNIX_BASIC and friends.
3310 data_len = 4 /* flags */
3317 + 4 /* pad/reserved */
3318 + (conn->server_info->utok.ngroups * 8)
3320 + (conn->server_info->ptok->num_sids *
3324 SIVAL(pdata, 0, flags);
3325 SIVAL(pdata, 4, SMB_WHOAMI_MASK);
3327 (uint64_t)conn->server_info->utok.uid);
3328 SBIG_UINT(pdata, 16,
3329 (uint64_t)conn->server_info->utok.gid);
3332 if (data_len >= max_data_bytes) {
3333 /* Potential overflow, skip the GIDs and SIDs. */
3335 SIVAL(pdata, 24, 0); /* num_groups */
3336 SIVAL(pdata, 28, 0); /* num_sids */
3337 SIVAL(pdata, 32, 0); /* num_sid_bytes */
3338 SIVAL(pdata, 36, 0); /* reserved */
3344 SIVAL(pdata, 24, conn->server_info->utok.ngroups);
3345 SIVAL(pdata, 28, conn->server_info->num_sids);
3347 /* We walk the SID list twice, but this call is fairly
3348 * infrequent, and I don't expect that it's performance
3349 * sensitive -- jpeach
3351 for (i = 0, sid_bytes = 0;
3352 i < conn->server_info->ptok->num_sids; ++i) {
3353 sid_bytes += ndr_size_dom_sid(
3354 &conn->server_info->ptok->user_sids[i],
3359 /* SID list byte count */
3360 SIVAL(pdata, 32, sid_bytes);
3362 /* 4 bytes pad/reserved - must be zero */
3363 SIVAL(pdata, 36, 0);
3367 for (i = 0; i < conn->server_info->utok.ngroups; ++i) {
3368 SBIG_UINT(pdata, data_len,
3369 (uint64_t)conn->server_info->utok.groups[i]);
3375 i < conn->server_info->ptok->num_sids; ++i) {
3376 int sid_len = ndr_size_dom_sid(
3377 &conn->server_info->ptok->user_sids[i],
3381 sid_linearize(pdata + data_len, sid_len,
3382 &conn->server_info->ptok->user_sids[i]);
3383 data_len += sid_len;
3389 case SMB_MAC_QUERY_FS_INFO:
3391 * Thursby MAC extension... ONLY on NTFS filesystems
3392 * once we do streams then we don't need this
3394 if (strequal(lp_fstype(SNUM(conn)),"NTFS")) {
3396 SIVAL(pdata,84,0x100); /* Don't support mac... */
3401 return NT_STATUS_INVALID_LEVEL;
3404 *ret_data_len = data_len;
3405 return NT_STATUS_OK;
3408 /****************************************************************************
3409 Reply to a TRANS2_QFSINFO (query filesystem info).
3410 ****************************************************************************/
3412 static void call_trans2qfsinfo(connection_struct *conn,
3413 struct smb_request *req,
3414 char **pparams, int total_params,
3415 char **ppdata, int total_data,
3416 unsigned int max_data_bytes)
3418 char *params = *pparams;
3419 uint16_t info_level;
3423 if (total_params < 2) {
3424 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3428 info_level = SVAL(params,0);
3430 if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3431 if (info_level != SMB_QUERY_CIFS_UNIX_INFO) {
3432 DEBUG(0,("call_trans2qfsinfo: encryption required "
3433 "and info level 0x%x sent.\n",
3434 (unsigned int)info_level));
3435 exit_server_cleanly("encryption required "
3441 DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
3443 status = smbd_do_qfsinfo(conn, req,
3448 if (!NT_STATUS_IS_OK(status)) {
3449 reply_nterror(req, status);
3453 send_trans2_replies(conn, req, params, 0, *ppdata, data_len,
3456 DEBUG( 4, ( "%s info_level = %d\n",
3457 smb_fn_name(req->cmd), info_level) );
3462 /****************************************************************************
3463 Reply to a TRANS2_SETFSINFO (set filesystem info).
3464 ****************************************************************************/
3466 static void call_trans2setfsinfo(connection_struct *conn,
3467 struct smb_request *req,
3468 char **pparams, int total_params,
3469 char **ppdata, int total_data,
3470 unsigned int max_data_bytes)
3472 char *pdata = *ppdata;
3473 char *params = *pparams;
3476 DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn))));
3479 if (total_params < 4) {
3480 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
3482 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
3486 info_level = SVAL(params,2);
3489 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION &&
3490 info_level != SMB_SET_CIFS_UNIX_INFO) {
3491 DEBUG(0,("call_trans2setfsinfo: not an allowed "
3492 "info level (0x%x) on IPC$.\n",
3493 (unsigned int)info_level));
3494 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
3499 if (ENCRYPTION_REQUIRED(conn) && !req->encrypted) {
3500 if (info_level != SMB_REQUEST_TRANSPORT_ENCRYPTION) {
3501 DEBUG(0,("call_trans2setfsinfo: encryption required "
3502 "and info level 0x%x sent.\n",
3503 (unsigned int)info_level));
3504 exit_server_cleanly("encryption required "
3510 switch(info_level) {
3511 case SMB_SET_CIFS_UNIX_INFO:
3513 uint16 client_unix_major;
3514 uint16 client_unix_minor;
3515 uint32 client_unix_cap_low;
3516 uint32 client_unix_cap_high;
3518 if (!lp_unix_extensions()) {
3520 NT_STATUS_INVALID_LEVEL);
3524 /* There should be 12 bytes of capabilities set. */
3525 if (total_data < 8) {
3528 NT_STATUS_INVALID_PARAMETER);
3531 client_unix_major = SVAL(pdata,0);
3532 client_unix_minor = SVAL(pdata,2);
3533 client_unix_cap_low = IVAL(pdata,4);
3534 client_unix_cap_high = IVAL(pdata,8);
3535 /* Just print these values for now. */
3536 DEBUG(10,("call_trans2setfsinfo: set unix info. major = %u, minor = %u \
3537 cap_low = 0x%x, cap_high = 0x%x\n",
3538 (unsigned int)client_unix_major,
3539 (unsigned int)client_unix_minor,
3540 (unsigned int)client_unix_cap_low,
3541 (unsigned int)client_unix_cap_high ));
3543 /* Here is where we must switch to posix pathname processing... */
3544 if (client_unix_cap_low & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3545 lp_set_posix_pathnames();
3546 mangle_change_to_posix();
3549 if ((client_unix_cap_low & CIFS_UNIX_FCNTL_LOCKS_CAP) &&
3550 !(client_unix_cap_low & CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP)) {
3551 /* Client that knows how to do posix locks,
3552 * but not posix open/mkdir operations. Set a
3553 * default type for read/write checks. */
3555 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK);
3561 case SMB_REQUEST_TRANSPORT_ENCRYPTION:
3564 size_t param_len = 0;
3565 size_t data_len = total_data;
3567 if (!lp_unix_extensions()) {
3570 NT_STATUS_INVALID_LEVEL);
3574 if (lp_smb_encrypt(SNUM(conn)) == false) {
3577 NT_STATUS_NOT_SUPPORTED);
3581 DEBUG( 4,("call_trans2setfsinfo: "
3582 "request transport encryption.\n"));
3584 status = srv_request_encryption_setup(conn,
3585 (unsigned char **)ppdata,
3587 (unsigned char **)pparams,
3590 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
3591 !NT_STATUS_IS_OK(status)) {
3592 reply_nterror(req, status);
3596 send_trans2_replies(conn, req,
3603 if (NT_STATUS_IS_OK(status)) {
3604 /* Server-side transport
3605 * encryption is now *on*. */
3606 status = srv_encryption_start(conn);
3607 if (!NT_STATUS_IS_OK(status)) {
3608 exit_server_cleanly(
3609 "Failure in setting "
3610 "up encrypted transport");
3616 case SMB_FS_QUOTA_INFORMATION:
3618 files_struct *fsp = NULL;
3619 SMB_NTQUOTA_STRUCT quotas;
3621 ZERO_STRUCT(quotas);
3624 if ((conn->server_info->utok.uid != sec_initial_uid())
3625 ||!CAN_WRITE(conn)) {
3626 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
3627 lp_servicename(SNUM(conn)),
3628 conn->server_info->unix_name));
3629 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
3633 /* note: normaly there're 48 bytes,
3634 * but we didn't use the last 6 bytes for now
3637 fsp = file_fsp(req, SVAL(params,0));
3639 if (!check_fsp_ntquota_handle(conn, req,
3641 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
3643 req, NT_STATUS_INVALID_HANDLE);
3647 if (total_data < 42) {
3648 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
3652 NT_STATUS_INVALID_PARAMETER);
3656 /* unknown_1 24 NULL bytes in pdata*/
3658 /* the soft quotas 8 bytes (uint64_t)*/
3659 quotas.softlim = (uint64_t)IVAL(pdata,24);
3660 #ifdef LARGE_SMB_OFF_T
3661 quotas.softlim |= (((uint64_t)IVAL(pdata,28)) << 32);
3662 #else /* LARGE_SMB_OFF_T */
3663 if ((IVAL(pdata,28) != 0)&&
3664 ((quotas.softlim != 0xFFFFFFFF)||
3665 (IVAL(pdata,28)!=0xFFFFFFFF))) {
3666 /* more than 32 bits? */
3669 NT_STATUS_INVALID_PARAMETER);
3672 #endif /* LARGE_SMB_OFF_T */
3674 /* the hard quotas 8 bytes (uint64_t)*/
3675 quotas.hardlim = (uint64_t)IVAL(pdata,32);
3676 #ifdef LARGE_SMB_OFF_T
3677 quotas.hardlim |= (((uint64_t)IVAL(pdata,36)) << 32);
3678 #else /* LARGE_SMB_OFF_T */
3679 if ((IVAL(pdata,36) != 0)&&
3680 ((quotas.hardlim != 0xFFFFFFFF)||
3681 (IVAL(pdata,36)!=0xFFFFFFFF))) {
3682 /* more than 32 bits? */
3685 NT_STATUS_INVALID_PARAMETER);
3688 #endif /* LARGE_SMB_OFF_T */
3690 /* quota_flags 2 bytes **/
3691 quotas.qflags = SVAL(pdata,40);
3693 /* unknown_2 6 NULL bytes follow*/
3695 /* now set the quotas */
3696 if (vfs_set_ntquota(fsp, SMB_USER_FS_QUOTA_TYPE, NULL, "as)!=0) {
3697 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn))));
3698 reply_nterror(req, map_nt_error_from_unix(errno));
3705 DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
3707 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
3713 * sending this reply works fine,
3714 * but I'm not sure it's the same
3715 * like windows do...
3718 reply_outbuf(req, 10, 0);
3721 #if defined(HAVE_POSIX_ACLS)
3722 /****************************************************************************
3723 Utility function to count the number of entries in a POSIX acl.
3724 ****************************************************************************/
3726 static unsigned int count_acl_entries(connection_struct *conn, SMB_ACL_T posix_acl)
3728 unsigned int ace_count = 0;
3729 int entry_id = SMB_ACL_FIRST_ENTRY;
3730 SMB_ACL_ENTRY_T entry;
3732 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3734 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3735 entry_id = SMB_ACL_NEXT_ENTRY;
3742 /****************************************************************************
3743 Utility function to marshall a POSIX acl into wire format.
3744 ****************************************************************************/
3746 static bool marshall_posix_acl(connection_struct *conn, char *pdata, SMB_STRUCT_STAT *pst, SMB_ACL_T posix_acl)
3748 int entry_id = SMB_ACL_FIRST_ENTRY;
3749 SMB_ACL_ENTRY_T entry;
3751 while ( posix_acl && (SMB_VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
3752 SMB_ACL_TAG_T tagtype;
3753 SMB_ACL_PERMSET_T permset;
3754 unsigned char perms = 0;
3755 unsigned int own_grp;
3758 if (entry_id == SMB_ACL_FIRST_ENTRY) {
3759 entry_id = SMB_ACL_NEXT_ENTRY;
3762 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1) {
3763 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
3767 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1) {
3768 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
3772 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? SMB_POSIX_ACL_READ : 0);
3773 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? SMB_POSIX_ACL_WRITE : 0);
3774 perms |= (SMB_VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? SMB_POSIX_ACL_EXECUTE : 0);
3776 SCVAL(pdata,1,perms);
3779 case SMB_ACL_USER_OBJ:
3780 SCVAL(pdata,0,SMB_POSIX_ACL_USER_OBJ);
3781 own_grp = (unsigned int)pst->st_ex_uid;
3782 SIVAL(pdata,2,own_grp);
3787 uid_t *puid = (uid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3789 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3792 own_grp = (unsigned int)*puid;
3793 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
3794 SCVAL(pdata,0,SMB_POSIX_ACL_USER);
3795 SIVAL(pdata,2,own_grp);
3799 case SMB_ACL_GROUP_OBJ:
3800 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP_OBJ);
3801 own_grp = (unsigned int)pst->st_ex_gid;
3802 SIVAL(pdata,2,own_grp);
3807 gid_t *pgid= (gid_t *)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
3809 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3812 own_grp = (unsigned int)*pgid;
3813 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
3814 SCVAL(pdata,0,SMB_POSIX_ACL_GROUP);
3815 SIVAL(pdata,2,own_grp);
3820 SCVAL(pdata,0,SMB_POSIX_ACL_MASK);
3821 SIVAL(pdata,2,0xFFFFFFFF);
3822 SIVAL(pdata,6,0xFFFFFFFF);
3825 SCVAL(pdata,0,SMB_POSIX_ACL_OTHER);
3826 SIVAL(pdata,2,0xFFFFFFFF);
3827 SIVAL(pdata,6,0xFFFFFFFF);
3830 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
3833 pdata += SMB_POSIX_ACL_ENTRY_SIZE;
3840 /****************************************************************************
3841 Store the FILE_UNIX_BASIC info.
3842 ****************************************************************************/
3844 static char *store_file_unix_basic(connection_struct *conn,
3847 const SMB_STRUCT_STAT *psbuf)
3849 DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
3850 DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf->st_ex_mode));
3852 SOFF_T(pdata,0,get_file_size_stat(psbuf)); /* File size 64 Bit */
3855 SOFF_T(pdata,0,SMB_VFS_GET_ALLOC_SIZE(conn,fsp,psbuf)); /* Number of bytes used on disk - 64 Bit */
3858 put_long_date_timespec(pdata, psbuf->st_ex_ctime); /* Change Time 64 Bit */
3859 put_long_date_timespec(pdata+8, psbuf->st_ex_atime); /* Last access time 64 Bit */
3860 put_long_date_timespec(pdata+16, psbuf->st_ex_mtime); /* Last modification time 64 Bit */
3863 SIVAL(pdata,0,psbuf->st_ex_uid); /* user id for the owner */
3867 SIVAL(pdata,0,psbuf->st_ex_gid); /* group id of owner */
3871 SIVAL(pdata,0,unix_filetype(psbuf->st_ex_mode));
3874 SIVAL(pdata,0,unix_dev_major(psbuf->st_ex_rdev)); /* Major device number if type is device */
3878 SIVAL(pdata,0,unix_dev_minor(psbuf->st_ex_rdev)); /* Minor device number if type is device */
3882 SINO_T_VAL(pdata,0,(SMB_INO_T)psbuf->st_ex_ino); /* inode number */
3885 SIVAL(pdata,0, unix_perms_to_wire(psbuf->st_ex_mode)); /* Standard UNIX file permissions */
3889 SIVAL(pdata,0,psbuf->st_ex_nlink); /* number of hard links */
3896 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
3897 * the chflags(2) (or equivalent) flags.
3899 * XXX: this really should be behind the VFS interface. To do this, we would
3900 * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
3901 * Each VFS module could then implement its own mapping as appropriate for the
3902 * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
3904 static const struct {unsigned stat_fflag; unsigned smb_fflag;}
3908 { UF_NODUMP, EXT_DO_NOT_BACKUP },
3912 { UF_IMMUTABLE, EXT_IMMUTABLE },
3916 { UF_APPEND, EXT_OPEN_APPEND_ONLY },
3920 { UF_HIDDEN, EXT_HIDDEN },
3923 /* Do not remove. We need to guarantee that this array has at least one
3924 * entry to build on HP-UX.
3930 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT *psbuf,
3931 uint32 *smb_fflags, uint32 *smb_fmask)
3935 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
3936 *smb_fmask |= info2_flags_map[i].smb_fflag;
3937 if (psbuf->st_ex_flags & info2_flags_map[i].stat_fflag) {
3938 *smb_fflags |= info2_flags_map[i].smb_fflag;
3943 static bool map_info2_flags_to_sbuf(const SMB_STRUCT_STAT *psbuf,
3944 const uint32 smb_fflags,
3945 const uint32 smb_fmask,
3948 uint32 max_fmask = 0;
3951 *stat_fflags = psbuf->st_ex_flags;
3953 /* For each flags requested in smb_fmask, check the state of the
3954 * corresponding flag in smb_fflags and set or clear the matching
3958 for (i = 0; i < ARRAY_SIZE(info2_flags_map); ++i) {
3959 max_fmask |= info2_flags_map[i].smb_fflag;
3960 if (smb_fmask & info2_flags_map[i].smb_fflag) {
3961 if (smb_fflags & info2_flags_map[i].smb_fflag) {
3962 *stat_fflags |= info2_flags_map[i].stat_fflag;
3964 *stat_fflags &= ~info2_flags_map[i].stat_fflag;
3969 /* If smb_fmask is asking to set any bits that are not supported by
3970 * our flag mappings, we should fail.
3972 if ((smb_fmask & max_fmask) != smb_fmask) {
3980 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
3981 * of file flags and birth (create) time.
3983 static char *store_file_unix_basic_info2(connection_struct *conn,
3986 const SMB_STRUCT_STAT *psbuf)
3988 uint32 file_flags = 0;
3989 uint32 flags_mask = 0;
3991 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
3993 /* Create (birth) time 64 bit */
3994 put_long_date_timespec(pdata, psbuf->st_ex_btime);
3997 map_info2_flags_from_sbuf(psbuf, &file_flags, &flags_mask);
3998 SIVAL(pdata, 0, file_flags); /* flags */
3999 SIVAL(pdata, 4, flags_mask); /* mask */
4005 static NTSTATUS marshall_stream_info(unsigned int num_streams,
4006 const struct stream_struct *streams,
4008 unsigned int max_data_bytes,
4009 unsigned int *data_size)
4012 unsigned int ofs = 0;
4014 for (i = 0; i < num_streams && ofs <= max_data_bytes; i++) {
4015 unsigned int next_offset;
4017 smb_ucs2_t *namebuf;
4019 if (!push_ucs2_talloc(talloc_tos(), &namebuf,
4020 streams[i].name, &namelen) ||
4023 return NT_STATUS_INVALID_PARAMETER;
4027 * name_buf is now null-terminated, we need to marshall as not
4033 SIVAL(data, ofs+4, namelen);
4034 SOFF_T(data, ofs+8, streams[i].size);
4035 SOFF_T(data, ofs+16, streams[i].alloc_size);
4036 memcpy(data+ofs+24, namebuf, namelen);
4037 TALLOC_FREE(namebuf);
4039 next_offset = ofs + 24 + namelen;
4041 if (i == num_streams-1) {
4042 SIVAL(data, ofs, 0);
4045 unsigned int align = ndr_align_size(next_offset, 8);
4047 memset(data+next_offset, 0, align);
4048 next_offset += align;
4050 SIVAL(data, ofs, next_offset - ofs);
4059 return NT_STATUS_OK;
4062 /****************************************************************************
4063 Reply to a TRANSACT2_QFILEINFO on a PIPE !
4064 ****************************************************************************/
4066 static void call_trans2qpipeinfo(connection_struct *conn,
4067 struct smb_request *req,
4068 unsigned int tran_call,
4069 char **pparams, int total_params,
4070 char **ppdata, int total_data,
4071 unsigned int max_data_bytes)
4073 char *params = *pparams;
4074 char *pdata = *ppdata;
4075 unsigned int data_size = 0;
4076 unsigned int param_size = 2;
4081 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4085 if (total_params < 4) {
4086 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4090 fsp = file_fsp(req, SVAL(params,0));
4091 if (!fsp_is_np(fsp)) {
4092 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
4096 info_level = SVAL(params,2);
4098 *pparams = (char *)SMB_REALLOC(*pparams,2);
4099 if (*pparams == NULL) {
4100 reply_nterror(req, NT_STATUS_NO_MEMORY);
4105 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4106 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4107 if (*ppdata == NULL ) {
4108 reply_nterror(req, NT_STATUS_NO_MEMORY);
4113 switch (info_level) {
4114 case SMB_FILE_STANDARD_INFORMATION:
4116 SOFF_T(pdata,0,4096LL);
4123 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4127 send_trans2_replies(conn, req, params, param_size, *ppdata, data_size,
4133 NTSTATUS smbd_do_qfilepathinfo(connection_struct *conn,
4134 TALLOC_CTX *mem_ctx,
4135 uint16_t info_level,
4137 struct smb_filename *smb_fname,
4138 bool delete_pending,
4139 struct timespec write_time_ts,
4141 struct ea_list *ea_list,
4142 int lock_data_count,
4145 unsigned int max_data_bytes,
4147 unsigned int *pdata_size)
4149 char *pdata = *ppdata;
4150 char *dstart, *dend;
4151 unsigned int data_size;
4152 struct timespec create_time_ts, mtime_ts, atime_ts, ctime_ts;
4153 time_t create_time, mtime, atime, c_time;
4154 SMB_STRUCT_STAT *psbuf = &smb_fname->st;
4161 uint64_t file_size = 0;
4163 uint64_t allocation_size = 0;
4164 uint64_t file_index = 0;
4165 uint32_t access_mask = 0;
4167 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
4168 return NT_STATUS_INVALID_LEVEL;
4171 DEBUG(5,("smbd_do_qfilepathinfo: %s (fnum = %d) level=%d max_data=%u\n",
4172 smb_fname_str_dbg(smb_fname), fsp ? fsp->fnum : -1,
4173 info_level, max_data_bytes));
4176 mode = dos_mode_msdfs(conn, smb_fname);
4178 mode = dos_mode(conn, smb_fname);
4181 mode = FILE_ATTRIBUTE_NORMAL;
4183 nlink = psbuf->st_ex_nlink;
4185 if (nlink && (mode&aDIR)) {
4189 if ((nlink > 0) && delete_pending) {
4193 data_size = max_data_bytes + DIR_ENTRY_SAFETY_MARGIN;
4194 *ppdata = (char *)SMB_REALLOC(*ppdata, data_size);
4195 if (*ppdata == NULL) {
4196 return NT_STATUS_NO_MEMORY;
4200 dend = dstart + data_size - 1;
4202 if (!null_timespec(write_time_ts) && !INFO_LEVEL_IS_UNIX(info_level)) {
4203 update_stat_ex_mtime(psbuf, write_time_ts);
4206 create_time_ts = get_create_timespec(conn, fsp, smb_fname);
4207 mtime_ts = psbuf->st_ex_mtime;
4208 atime_ts = psbuf->st_ex_atime;
4209 ctime_ts = get_change_timespec(conn, fsp, smb_fname);
4211 if (lp_dos_filetime_resolution(SNUM(conn))) {
4212 dos_filetime_timespec(&create_time_ts);
4213 dos_filetime_timespec(&mtime_ts);
4214 dos_filetime_timespec(&atime_ts);
4215 dos_filetime_timespec(&ctime_ts);
4218 create_time = convert_timespec_to_time_t(create_time_ts);
4219 mtime = convert_timespec_to_time_t(mtime_ts);
4220 atime = convert_timespec_to_time_t(atime_ts);
4221 c_time = convert_timespec_to_time_t(ctime_ts);
4223 p = strrchr_m(smb_fname->base_name,'/');
4225 base_name = smb_fname->base_name;
4229 /* NT expects the name to be in an exact form of the *full*
4230 filename. See the trans2 torture test */
4231 if (ISDOT(base_name)) {
4232 dos_fname = talloc_strdup(mem_ctx, "\\");
4234 return NT_STATUS_NO_MEMORY;
4237 dos_fname = talloc_asprintf(mem_ctx,
4239 smb_fname->base_name);
4241 return NT_STATUS_NO_MEMORY;
4243 if (is_ntfs_stream_smb_fname(smb_fname)) {
4244 dos_fname = talloc_asprintf(dos_fname, "%s",
4245 smb_fname->stream_name);
4247 return NT_STATUS_NO_MEMORY;
4251 string_replace(dos_fname, '/', '\\');
4254 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp, psbuf);
4257 /* Do we have this path open ? */
4259 struct file_id fileid = vfs_file_id_from_sbuf(conn, psbuf);
4260 fsp1 = file_find_di_first(fileid);
4261 if (fsp1 && fsp1->initial_allocation_size) {
4262 allocation_size = SMB_VFS_GET_ALLOC_SIZE(conn, fsp1, psbuf);
4266 if (!(mode & aDIR)) {
4267 file_size = get_file_size_stat(psbuf);
4271 pos = fsp->fh->position_information;
4275 access_mask = fsp->access_mask;
4277 /* GENERIC_EXECUTE mapping from Windows */
4278 access_mask = 0x12019F;
4281 /* This should be an index number - looks like
4284 I think this causes us to fail the IFSKIT
4285 BasicFileInformationTest. -tpot */
4286 file_index = ((psbuf->st_ex_ino) & UINT32_MAX); /* FileIndexLow */
4287 file_index |= ((uint64_t)((psbuf->st_ex_dev) & UINT32_MAX)) << 32; /* FileIndexHigh */
4289 switch (info_level) {
4290 case SMB_INFO_STANDARD:
4291 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_STANDARD\n"));
4293 srv_put_dos_date2(pdata,l1_fdateCreation,create_time);
4294 srv_put_dos_date2(pdata,l1_fdateLastAccess,atime);
4295 srv_put_dos_date2(pdata,l1_fdateLastWrite,mtime); /* write time */
4296 SIVAL(pdata,l1_cbFile,(uint32)file_size);
4297 SIVAL(pdata,l1_cbFileAlloc,(uint32)allocation_size);
4298 SSVAL(pdata,l1_attrFile,mode);
4301 case SMB_INFO_QUERY_EA_SIZE:
4303 unsigned int ea_size =
4304 estimate_ea_size(conn, fsp,
4305 smb_fname->base_name);
4306 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
4308 srv_put_dos_date2(pdata,0,create_time);
4309 srv_put_dos_date2(pdata,4,atime);
4310 srv_put_dos_date2(pdata,8,mtime); /* write time */
4311 SIVAL(pdata,12,(uint32)file_size);
4312 SIVAL(pdata,16,(uint32)allocation_size);
4313 SSVAL(pdata,20,mode);
4314 SIVAL(pdata,22,ea_size);
4318 case SMB_INFO_IS_NAME_VALID:
4319 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
4321 /* os/2 needs this ? really ?*/
4322 return NT_STATUS_DOS(ERRDOS, ERRbadfunc);
4324 /* This is only reached for qpathinfo */
4328 case SMB_INFO_QUERY_EAS_FROM_LIST:
4330 size_t total_ea_len = 0;
4331 struct ea_list *ea_file_list = NULL;
4333 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
4336 get_ea_list_from_file(mem_ctx, conn, fsp,
4337 smb_fname->base_name,
4339 ea_list = ea_list_union(ea_list, ea_file_list, &total_ea_len);
4341 if (!ea_list || (total_ea_len > data_size)) {
4343 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
4347 data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
4351 case SMB_INFO_QUERY_ALL_EAS:
4353 /* We have data_size bytes to put EA's into. */
4354 size_t total_ea_len = 0;
4356 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
4358 ea_list = get_ea_list_from_file(mem_ctx, conn, fsp,
4359 smb_fname->base_name,
4361 if (!ea_list || (total_ea_len > data_size)) {
4363 SIVAL(pdata,0,4); /* EA List Length must be set to 4 if no EA's. */
4367 data_size = fill_ea_buffer(mem_ctx, pdata, data_size, conn, ea_list);
4371 case 0xFF0F:/*SMB2_INFO_QUERY_ALL_EAS*/
4373 /* We have data_size bytes to put EA's into. */
4374 size_t total_ea_len = 0;
4375 struct ea_list *ea_file_list = NULL;
4377 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_INFO_QUERY_ALL_EAS\n"));
4379 /*TODO: add filtering and index handling */
4382 get_ea_list_from_file(mem_ctx, conn, fsp,
4383 smb_fname->base_name,
4385 if (!ea_file_list) {
4386 return NT_STATUS_NO_EAS_ON_FILE;
4389 status = fill_ea_chained_buffer(mem_ctx,
4393 conn, ea_file_list);
4394 if (!NT_STATUS_IS_OK(status)) {
4400 case SMB_FILE_BASIC_INFORMATION:
4401 case SMB_QUERY_FILE_BASIC_INFO:
4403 if (info_level == SMB_QUERY_FILE_BASIC_INFO) {
4404 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
4405 data_size = 36; /* w95 returns 40 bytes not 36 - why ?. */
4407 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
4411 put_long_date_timespec(pdata,create_time_ts);
4412 put_long_date_timespec(pdata+8,atime_ts);
4413 put_long_date_timespec(pdata+16,mtime_ts); /* write time */
4414 put_long_date_timespec(pdata+24,ctime_ts); /* change time */
4415 SIVAL(pdata,32,mode);
4417 DEBUG(5,("SMB_QFBI - "));
4418 DEBUG(5,("create: %s ", ctime(&create_time)));
4419 DEBUG(5,("access: %s ", ctime(&atime)));
4420 DEBUG(5,("write: %s ", ctime(&mtime)));
4421 DEBUG(5,("change: %s ", ctime(&c_time)));
4422 DEBUG(5,("mode: %x\n", mode));
4425 case SMB_FILE_STANDARD_INFORMATION:
4426 case SMB_QUERY_FILE_STANDARD_INFO:
4428 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
4430 SOFF_T(pdata,0,allocation_size);
4431 SOFF_T(pdata,8,file_size);
4432 SIVAL(pdata,16,nlink);
4433 SCVAL(pdata,20,delete_pending?1:0);
4434 SCVAL(pdata,21,(mode&aDIR)?1:0);
4435 SSVAL(pdata,22,0); /* Padding. */
4438 case SMB_FILE_EA_INFORMATION:
4439 case SMB_QUERY_FILE_EA_INFO:
4441 unsigned int ea_size =
4442 estimate_ea_size(conn, fsp, smb_fname->base_name);
4443 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
4445 SIVAL(pdata,0,ea_size);
4449 /* Get the 8.3 name - used if NT SMB was negotiated. */
4450 case SMB_QUERY_FILE_ALT_NAME_INFO:
4451 case SMB_FILE_ALTERNATE_NAME_INFORMATION:
4454 char mangled_name[13];
4455 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
4456 if (!name_to_8_3(base_name,mangled_name,
4457 True,conn->params)) {
4458 return NT_STATUS_NO_MEMORY;
4460 len = srvstr_push(dstart, flags2,
4461 pdata+4, mangled_name,
4462 PTR_DIFF(dend, pdata+4),
4464 data_size = 4 + len;
4469 case SMB_QUERY_FILE_NAME_INFO:
4473 this must be *exactly* right for ACLs on mapped drives to work
4475 len = srvstr_push(dstart, flags2,
4477 PTR_DIFF(dend, pdata+4),
4479 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
4480 data_size = 4 + len;
4485 case SMB_FILE_ALLOCATION_INFORMATION:
4486 case SMB_QUERY_FILE_ALLOCATION_INFO:
4487 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
4489 SOFF_T(pdata,0,allocation_size);
4492 case SMB_FILE_END_OF_FILE_INFORMATION:
4493 case SMB_QUERY_FILE_END_OF_FILEINFO:
4494 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
4496 SOFF_T(pdata,0,file_size);
4499 case SMB_QUERY_FILE_ALL_INFO:
4500 case SMB_FILE_ALL_INFORMATION:
4503 unsigned int ea_size =
4504 estimate_ea_size(conn, fsp, smb_fname->base_name);
4505 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
4506 put_long_date_timespec(pdata,create_time_ts);
4507 put_long_date_timespec(pdata+8,atime_ts);
4508 put_long_date_timespec(pdata+16,mtime_ts); /* write time */
4509 put_long_date_timespec(pdata+24,ctime_ts); /* change time */
4510 SIVAL(pdata,32,mode);
4511 SIVAL(pdata,36,0); /* padding. */
4513 SOFF_T(pdata,0,allocation_size);
4514 SOFF_T(pdata,8,file_size);
4515 SIVAL(pdata,16,nlink);
4516 SCVAL(pdata,20,delete_pending);
4517 SCVAL(pdata,21,(mode&aDIR)?1:0);
4520 SIVAL(pdata,0,ea_size);
4521 pdata += 4; /* EA info */
4522 len = srvstr_push(dstart, flags2,
4524 PTR_DIFF(dend, pdata+4),
4528 data_size = PTR_DIFF(pdata,(*ppdata));
4532 case 0xFF12:/*SMB2_FILE_ALL_INFORMATION*/
4535 unsigned int ea_size =
4536 estimate_ea_size(conn, fsp, smb_fname->base_name);
4537 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_FILE_ALL_INFORMATION\n"));
4538 put_long_date_timespec(pdata+0x00,create_time_ts);
4539 put_long_date_timespec(pdata+0x08,atime_ts);
4540 put_long_date_timespec(pdata+0x10,mtime_ts); /* write time */
4541 put_long_date_timespec(pdata+0x18,ctime_ts); /* change time */
4542 SIVAL(pdata, 0x20, mode);
4543 SIVAL(pdata, 0x24, 0); /* padding. */
4544 SBVAL(pdata, 0x28, allocation_size);
4545 SBVAL(pdata, 0x30, file_size);
4546 SIVAL(pdata, 0x38, nlink);
4547 SCVAL(pdata, 0x3C, delete_pending);
4548 SCVAL(pdata, 0x3D, (mode&aDIR)?1:0);
4549 SSVAL(pdata, 0x3E, 0); /* padding */
4550 SBVAL(pdata, 0x40, file_index);
4551 SIVAL(pdata, 0x48, ea_size);
4552 SIVAL(pdata, 0x4C, access_mask);
4553 SBVAL(pdata, 0x50, pos);
4554 SIVAL(pdata, 0x58, mode); /*TODO: mode != mode fix this!!! */
4555 SIVAL(pdata, 0x5C, 0); /* No alignment needed. */
4559 len = srvstr_push(dstart, flags2,
4561 PTR_DIFF(dend, pdata+4),
4565 data_size = PTR_DIFF(pdata,(*ppdata));
4568 case SMB_FILE_INTERNAL_INFORMATION:
4570 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
4571 SBVAL(pdata, 0, file_index);
4575 case SMB_FILE_ACCESS_INFORMATION:
4576 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
4577 SIVAL(pdata, 0, access_mask);
4581 case SMB_FILE_NAME_INFORMATION:
4582 /* Pathname with leading '\'. */
4585 byte_len = dos_PutUniCode(pdata+4,dos_fname,(size_t)max_data_bytes,False);
4586 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
4587 SIVAL(pdata,0,byte_len);
4588 data_size = 4 + byte_len;
4592 case SMB_FILE_DISPOSITION_INFORMATION:
4593 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
4595 SCVAL(pdata,0,delete_pending);
4598 case SMB_FILE_POSITION_INFORMATION:
4599 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
4601 SOFF_T(pdata,0,pos);
4604 case SMB_FILE_MODE_INFORMATION:
4605 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
4606 SIVAL(pdata,0,mode);
4610 case SMB_FILE_ALIGNMENT_INFORMATION:
4611 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
4612 SIVAL(pdata,0,0); /* No alignment needed. */
4617 * NT4 server just returns "invalid query" to this - if we try
4618 * to answer it then NTws gets a BSOD! (tridge). W2K seems to
4621 /* The first statement above is false - verified using Thursby
4622 * client against NT4 -- gcolley.
4624 case SMB_QUERY_FILE_STREAM_INFO:
4625 case SMB_FILE_STREAM_INFORMATION: {
4626 unsigned int num_streams;
4627 struct stream_struct *streams;
4629 DEBUG(10,("smbd_do_qfilepathinfo: "
4630 "SMB_FILE_STREAM_INFORMATION\n"));
4632 if (is_ntfs_stream_smb_fname(smb_fname)) {
4633 return NT_STATUS_INVALID_PARAMETER;
4636 status = SMB_VFS_STREAMINFO(
4637 conn, fsp, smb_fname->base_name, talloc_tos(),
4638 &num_streams, &streams);
4640 if (!NT_STATUS_IS_OK(status)) {
4641 DEBUG(10, ("could not get stream info: %s\n",
4642 nt_errstr(status)));
4646 status = marshall_stream_info(num_streams, streams,
4647 pdata, max_data_bytes,
4650 if (!NT_STATUS_IS_OK(status)) {
4651 DEBUG(10, ("marshall_stream_info failed: %s\n",
4652 nt_errstr(status)));
4656 TALLOC_FREE(streams);
4660 case SMB_QUERY_COMPRESSION_INFO:
4661 case SMB_FILE_COMPRESSION_INFORMATION:
4662 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
4663 SOFF_T(pdata,0,file_size);
4664 SIVAL(pdata,8,0); /* ??? */
4665 SIVAL(pdata,12,0); /* ??? */
4669 case SMB_FILE_NETWORK_OPEN_INFORMATION:
4670 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
4671 put_long_date_timespec(pdata,create_time_ts);
4672 put_long_date_timespec(pdata+8,atime_ts);
4673 put_long_date_timespec(pdata+16,mtime_ts); /* write time */
4674 put_long_date_timespec(pdata+24,ctime_ts); /* change time */
4675 SOFF_T(pdata,32,allocation_size);
4676 SOFF_T(pdata,40,file_size);
4677 SIVAL(pdata,48,mode);
4678 SIVAL(pdata,52,0); /* ??? */
4682 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION:
4683 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
4684 SIVAL(pdata,0,mode);
4690 * CIFS UNIX Extensions.
4693 case SMB_QUERY_FILE_UNIX_BASIC:
4695 pdata = store_file_unix_basic(conn, pdata, fsp, psbuf);
4696 data_size = PTR_DIFF(pdata,(*ppdata));
4700 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC "));
4702 for (i=0; i<100; i++)
4703 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
4709 case SMB_QUERY_FILE_UNIX_INFO2:
4711 pdata = store_file_unix_basic_info2(conn, pdata, fsp, psbuf);
4712 data_size = PTR_DIFF(pdata,(*ppdata));
4716 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
4718 for (i=0; i<100; i++)
4719 DEBUG(4,("%d=%x, ",i, (*ppdata)[i]));
4725 case SMB_QUERY_FILE_UNIX_LINK:
4728 char *buffer = TALLOC_ARRAY(mem_ctx, char, PATH_MAX+1);
4731 return NT_STATUS_NO_MEMORY;
4734 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
4736 if(!S_ISLNK(psbuf->st_ex_mode)) {
4737 return NT_STATUS_DOS(ERRSRV, ERRbadlink);
4740 return NT_STATUS_DOS(ERRDOS, ERRbadlink);
4742 len = SMB_VFS_READLINK(conn,
4743 smb_fname->base_name,
4746 return map_nt_error_from_unix(errno);
4749 len = srvstr_push(dstart, flags2,
4751 PTR_DIFF(dend, pdata),
4754 data_size = PTR_DIFF(pdata,(*ppdata));
4759 #if defined(HAVE_POSIX_ACLS)
4760 case SMB_QUERY_POSIX_ACL:
4762 SMB_ACL_T file_acl = NULL;
4763 SMB_ACL_T def_acl = NULL;
4764 uint16 num_file_acls = 0;
4765 uint16 num_def_acls = 0;
4767 if (fsp && !fsp->is_directory && (fsp->fh->fd != -1)) {
4768 file_acl = SMB_VFS_SYS_ACL_GET_FD(fsp);
4771 SMB_VFS_SYS_ACL_GET_FILE(conn,
4772 smb_fname->base_name,
4773 SMB_ACL_TYPE_ACCESS);
4776 if (file_acl == NULL && no_acl_syscall_error(errno)) {
4777 DEBUG(5,("smbd_do_qfilepathinfo: ACLs "
4778 "not implemented on "
4779 "filesystem containing %s\n",
4780 smb_fname->base_name));
4781 return NT_STATUS_NOT_IMPLEMENTED;
4784 if (S_ISDIR(psbuf->st_ex_mode)) {
4785 if (fsp && fsp->is_directory) {
4787 SMB_VFS_SYS_ACL_GET_FILE(
4789 fsp->fsp_name->base_name,
4790 SMB_ACL_TYPE_DEFAULT);
4793 SMB_VFS_SYS_ACL_GET_FILE(
4795 smb_fname->base_name,
4796 SMB_ACL_TYPE_DEFAULT);
4798 def_acl = free_empty_sys_acl(conn, def_acl);
4801 num_file_acls = count_acl_entries(conn, file_acl);
4802 num_def_acls = count_acl_entries(conn, def_acl);
4804 if ( data_size < (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE) {
4805 DEBUG(5,("smbd_do_qfilepathinfo: data_size too small (%u) need %u\n",
4807 (unsigned int)((num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE +
4808 SMB_POSIX_ACL_HEADER_SIZE) ));
4810 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4813 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4815 return NT_STATUS_BUFFER_TOO_SMALL;
4818 SSVAL(pdata,0,SMB_POSIX_ACL_VERSION);
4819 SSVAL(pdata,2,num_file_acls);
4820 SSVAL(pdata,4,num_def_acls);
4821 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE, psbuf, file_acl)) {
4823 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4826 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4828 return NT_STATUS_INTERNAL_ERROR;
4830 if (!marshall_posix_acl(conn, pdata + SMB_POSIX_ACL_HEADER_SIZE + (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE), psbuf, def_acl)) {
4832 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4835 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4837 return NT_STATUS_INTERNAL_ERROR;
4841 SMB_VFS_SYS_ACL_FREE_ACL(conn, file_acl);
4844 SMB_VFS_SYS_ACL_FREE_ACL(conn, def_acl);
4846 data_size = (num_file_acls + num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE + SMB_POSIX_ACL_HEADER_SIZE;
4852 case SMB_QUERY_POSIX_LOCK:
4857 enum brl_type lock_type;
4859 /* We need an open file with a real fd for this. */
4860 if (!fsp || fsp->is_directory || fsp->fh->fd == -1) {
4861 return NT_STATUS_INVALID_LEVEL;
4864 if (lock_data_count != POSIX_LOCK_DATA_SIZE) {
4865 return NT_STATUS_INVALID_PARAMETER;
4868 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
4869 case POSIX_LOCK_TYPE_READ:
4870 lock_type = READ_LOCK;
4872 case POSIX_LOCK_TYPE_WRITE:
4873 lock_type = WRITE_LOCK;
4875 case POSIX_LOCK_TYPE_UNLOCK:
4877 /* There's no point in asking for an unlock... */
4878 return NT_STATUS_INVALID_PARAMETER;
4881 lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
4882 #if defined(HAVE_LONGLONG)
4883 offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
4884 ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
4885 count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
4886 ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
4887 #else /* HAVE_LONGLONG */
4888 offset = (uint64_t)IVAL(pdata,POSIX_LOCK_START_OFFSET);
4889 count = (uint64_t)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
4890 #endif /* HAVE_LONGLONG */
4892 status = query_lock(fsp,
4899 if (ERROR_WAS_LOCK_DENIED(status)) {
4900 /* Here we need to report who has it locked... */
4901 data_size = POSIX_LOCK_DATA_SIZE;
4903 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, lock_type);
4904 SSVAL(pdata, POSIX_LOCK_FLAGS_OFFSET, 0);
4905 SIVAL(pdata, POSIX_LOCK_PID_OFFSET, lock_pid);
4906 #if defined(HAVE_LONGLONG)
4907 SIVAL(pdata, POSIX_LOCK_START_OFFSET, (uint32)(offset & 0xFFFFFFFF));
4908 SIVAL(pdata, POSIX_LOCK_START_OFFSET + 4, (uint32)((offset >> 32) & 0xFFFFFFFF));
4909 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, (uint32)(count & 0xFFFFFFFF));
4910 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET + 4, (uint32)((count >> 32) & 0xFFFFFFFF));
4911 #else /* HAVE_LONGLONG */
4912 SIVAL(pdata, POSIX_LOCK_START_OFFSET, offset);
4913 SIVAL(pdata, POSIX_LOCK_LEN_OFFSET, count);
4914 #endif /* HAVE_LONGLONG */
4916 } else if (NT_STATUS_IS_OK(status)) {
4917 /* For success we just return a copy of what we sent
4918 with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
4919 data_size = POSIX_LOCK_DATA_SIZE;
4920 memcpy(pdata, lock_data, POSIX_LOCK_DATA_SIZE);
4921 SSVAL(pdata, POSIX_LOCK_TYPE_OFFSET, POSIX_LOCK_TYPE_UNLOCK);
4929 return NT_STATUS_INVALID_LEVEL;
4932 *pdata_size = data_size;
4933 return NT_STATUS_OK;
4936 /****************************************************************************
4937 Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
4938 file name or file id).
4939 ****************************************************************************/
4941 static void call_trans2qfilepathinfo(connection_struct *conn,
4942 struct smb_request *req,
4943 unsigned int tran_call,
4944 char **pparams, int total_params,
4945 char **ppdata, int total_data,
4946 unsigned int max_data_bytes)
4948 char *params = *pparams;
4949 char *pdata = *ppdata;
4951 unsigned int data_size = 0;
4952 unsigned int param_size = 2;
4953 struct smb_filename *smb_fname = NULL;
4954 bool delete_pending = False;
4955 struct timespec write_time_ts;
4956 files_struct *fsp = NULL;
4957 struct file_id fileid;
4958 struct ea_list *ea_list = NULL;
4959 int lock_data_count = 0;
4960 char *lock_data = NULL;
4961 bool ms_dfs_link = false;
4962 NTSTATUS status = NT_STATUS_OK;
4965 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4969 ZERO_STRUCT(write_time_ts);
4971 if (tran_call == TRANSACT2_QFILEINFO) {
4972 if (total_params < 4) {
4973 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
4978 call_trans2qpipeinfo(conn, req, tran_call,
4979 pparams, total_params,
4985 fsp = file_fsp(req, SVAL(params,0));
4986 info_level = SVAL(params,2);
4988 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level));
4990 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
4991 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
4995 /* Initial check for valid fsp ptr. */
4996 if (!check_fsp_open(conn, req, fsp)) {
5000 status = copy_smb_filename(talloc_tos(), fsp->fsp_name,
5002 if (!NT_STATUS_IS_OK(status)) {
5003 reply_nterror(req, status);
5007 if(fsp->fake_file_handle) {
5009 * This is actually for the QUOTA_FAKE_FILE --metze
5012 /* We know this name is ok, it's already passed the checks. */
5014 } else if(fsp->is_directory || fsp->fh->fd == -1) {
5016 * This is actually a QFILEINFO on a directory
5017 * handle (returned from an NT SMB). NT5.0 seems
5018 * to do this call. JRA.
5021 if (INFO_LEVEL_IS_UNIX(info_level)) {
5022 /* Always do lstat for UNIX calls. */
5023 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5024 DEBUG(3,("call_trans2qfilepathinfo: "
5025 "SMB_VFS_LSTAT of %s failed "
5027 smb_fname_str_dbg(smb_fname),
5030 map_nt_error_from_unix(errno));
5033 } else if (SMB_VFS_STAT(conn, smb_fname)) {
5034 DEBUG(3,("call_trans2qfilepathinfo: "
5035 "SMB_VFS_STAT of %s failed (%s)\n",
5036 smb_fname_str_dbg(smb_fname),
5039 map_nt_error_from_unix(errno));
5043 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5044 get_file_infos(fileid, &delete_pending, &write_time_ts);
5047 * Original code - this is an open file.
5049 if (!check_fsp(conn, req, fsp)) {
5053 if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
5054 DEBUG(3, ("fstat of fnum %d failed (%s)\n",
5055 fsp->fnum, strerror(errno)));
5057 map_nt_error_from_unix(errno));
5060 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5061 get_file_infos(fileid, &delete_pending, &write_time_ts);
5068 if (total_params < 7) {
5069 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
5073 info_level = SVAL(params,0);
5075 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level));
5077 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
5078 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5082 srvstr_get_path(req, params, req->flags2, &fname, ¶ms[6],
5084 STR_TERMINATE, &status);
5085 if (!NT_STATUS_IS_OK(status)) {
5086 reply_nterror(req, status);
5090 status = filename_convert(req,
5092 req->flags2 & FLAGS2_DFS_PATHNAMES,
5097 if (!NT_STATUS_IS_OK(status)) {
5098 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
5099 reply_botherror(req,
5100 NT_STATUS_PATH_NOT_COVERED,
5101 ERRSRV, ERRbadpath);
5104 reply_nterror(req, status);
5108 /* If this is a stream, check if there is a delete_pending. */
5109 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
5110 && is_ntfs_stream_smb_fname(smb_fname)) {
5111 struct smb_filename *smb_fname_base = NULL;
5113 /* Create an smb_filename with stream_name == NULL. */
5115 create_synthetic_smb_fname(talloc_tos(),
5116 smb_fname->base_name,
5119 if (!NT_STATUS_IS_OK(status)) {
5120 reply_nterror(req, status);
5124 if (INFO_LEVEL_IS_UNIX(info_level)) {
5125 /* Always do lstat for UNIX calls. */
5126 if (SMB_VFS_LSTAT(conn, smb_fname_base) != 0) {
5127 DEBUG(3,("call_trans2qfilepathinfo: "
5128 "SMB_VFS_LSTAT of %s failed "
5130 smb_fname_str_dbg(smb_fname_base),
5132 TALLOC_FREE(smb_fname_base);
5134 map_nt_error_from_unix(errno));
5138 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
5139 DEBUG(3,("call_trans2qfilepathinfo: "
5140 "fileinfo of %s failed "
5142 smb_fname_str_dbg(smb_fname_base),
5144 TALLOC_FREE(smb_fname_base);
5146 map_nt_error_from_unix(errno));
5151 fileid = vfs_file_id_from_sbuf(conn,
5152 &smb_fname_base->st);
5153 TALLOC_FREE(smb_fname_base);
5154 get_file_infos(fileid, &delete_pending, NULL);
5155 if (delete_pending) {
5156 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5161 if (INFO_LEVEL_IS_UNIX(info_level)) {
5162 /* Always do lstat for UNIX calls. */
5163 if (SMB_VFS_LSTAT(conn, smb_fname)) {
5164 DEBUG(3,("call_trans2qfilepathinfo: "
5165 "SMB_VFS_LSTAT of %s failed (%s)\n",
5166 smb_fname_str_dbg(smb_fname),
5169 map_nt_error_from_unix(errno));
5173 } else if (!VALID_STAT(smb_fname->st) &&
5174 SMB_VFS_STAT(conn, smb_fname) &&
5175 (info_level != SMB_INFO_IS_NAME_VALID)) {
5176 ms_dfs_link = check_msdfs_link(conn,
5177 smb_fname->base_name,
5181 DEBUG(3,("call_trans2qfilepathinfo: "
5182 "SMB_VFS_STAT of %s failed (%s)\n",
5183 smb_fname_str_dbg(smb_fname),
5186 map_nt_error_from_unix(errno));
5191 fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
5192 get_file_infos(fileid, &delete_pending, &write_time_ts);
5193 if (delete_pending) {
5194 reply_nterror(req, NT_STATUS_DELETE_PENDING);
5199 DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d "
5200 "total_data=%d\n", smb_fname_str_dbg(smb_fname),
5201 fsp ? fsp->fnum : -1, info_level,tran_call,total_data));
5203 /* Pull out any data sent here before we realloc. */
5204 switch (info_level) {
5205 case SMB_INFO_QUERY_EAS_FROM_LIST:
5207 /* Pull any EA list from the data portion. */
5210 if (total_data < 4) {
5212 req, NT_STATUS_INVALID_PARAMETER);
5215 ea_size = IVAL(pdata,0);
5217 if (total_data > 0 && ea_size != total_data) {
5218 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
5219 total_data=%u (should be %u)\n", (unsigned int)total_data, (unsigned int)IVAL(pdata,0) ));
5221 req, NT_STATUS_INVALID_PARAMETER);
5225 if (!lp_ea_support(SNUM(conn))) {
5226 reply_doserror(req, ERRDOS,
5227 ERReasnotsupported);
5231 /* Pull out the list of names. */
5232 ea_list = read_ea_name_list(req, pdata + 4, ea_size - 4);
5235 req, NT_STATUS_INVALID_PARAMETER);
5241 case SMB_QUERY_POSIX_LOCK:
5243 if (fsp == NULL || fsp->fh->fd == -1) {
5244 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
5248 if (total_data != POSIX_LOCK_DATA_SIZE) {
5250 req, NT_STATUS_INVALID_PARAMETER);
5254 /* Copy the lock range data. */
5255 lock_data = (char *)TALLOC_MEMDUP(
5256 req, pdata, total_data);
5258 reply_nterror(req, NT_STATUS_NO_MEMORY);
5261 lock_data_count = total_data;
5267 *pparams = (char *)SMB_REALLOC(*pparams,2);
5268 if (*pparams == NULL) {
5269 reply_nterror(req, NT_STATUS_NO_MEMORY);
5276 * draft-leach-cifs-v1-spec-02.txt
5277 * 4.2.14 TRANS2_QUERY_PATH_INFORMATION: Get File Attributes given Path
5280 * The requested information is placed in the Data portion of the
5281 * transaction response. For the information levels greater than 0x100,
5282 * the transaction response has 1 parameter word which should be
5283 * ignored by the client.
5285 * However Windows only follows this rule for the IS_NAME_VALID call.
5287 switch (info_level) {
5288 case SMB_INFO_IS_NAME_VALID:
5293 if ((info_level & 0xFF00) == 0xFF00) {
5295 * We use levels that start with 0xFF00
5296 * internally to represent SMB2 specific levels
5298 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
5302 status = smbd_do_qfilepathinfo(conn, req, info_level,
5304 delete_pending, write_time_ts,
5305 ms_dfs_link, ea_list,
5306 lock_data_count, lock_data,
5307 req->flags2, max_data_bytes,
5308 ppdata, &data_size);
5309 if (!NT_STATUS_IS_OK(status)) {
5310 reply_nterror(req, status);
5314 send_trans2_replies(conn, req, params, param_size, *ppdata, data_size,
5320 /****************************************************************************
5321 Set a hard link (called by UNIX extensions and by NT rename with HARD link
5323 ****************************************************************************/
5325 NTSTATUS hardlink_internals(TALLOC_CTX *ctx,
5326 connection_struct *conn,
5327 const struct smb_filename *smb_fname_old,
5328 const struct smb_filename *smb_fname_new)
5330 NTSTATUS status = NT_STATUS_OK;
5332 /* source must already exist. */
5333 if (!VALID_STAT(smb_fname_old->st)) {
5334 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5337 /* Disallow if newname already exists. */
5338 if (VALID_STAT(smb_fname_new->st)) {
5339 return NT_STATUS_OBJECT_NAME_COLLISION;
5342 /* No links from a directory. */
5343 if (S_ISDIR(smb_fname_old->st.st_ex_mode)) {
5344 return NT_STATUS_FILE_IS_A_DIRECTORY;
5347 /* Setting a hardlink to/from a stream isn't currently supported. */
5348 if (is_ntfs_stream_smb_fname(smb_fname_old) ||
5349 is_ntfs_stream_smb_fname(smb_fname_new)) {
5350 return NT_STATUS_INVALID_PARAMETER;
5353 DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n",
5354 smb_fname_old->base_name, smb_fname_new->base_name));
5356 if (SMB_VFS_LINK(conn, smb_fname_old->base_name,
5357 smb_fname_new->base_name) != 0) {
5358 status = map_nt_error_from_unix(errno);
5359 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
5360 nt_errstr(status), smb_fname_old->base_name,
5361 smb_fname_new->base_name));
5366 /****************************************************************************
5367 Deal with setting the time from any of the setfilepathinfo functions.
5368 ****************************************************************************/
5370 NTSTATUS smb_set_file_time(connection_struct *conn,
5372 const struct smb_filename *smb_fname,
5373 struct smb_file_time *ft,
5374 bool setting_write_time)
5376 struct smb_filename *smb_fname_base = NULL;
5378 FILE_NOTIFY_CHANGE_LAST_ACCESS
5379 |FILE_NOTIFY_CHANGE_LAST_WRITE
5380 |FILE_NOTIFY_CHANGE_CREATION;
5383 if (!VALID_STAT(smb_fname->st)) {
5384 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5387 /* get some defaults (no modifications) if any info is zero or -1. */
5388 if (null_timespec(ft->create_time)) {
5389 action &= ~FILE_NOTIFY_CHANGE_CREATION;
5392 if (null_timespec(ft->atime)) {
5393 action &= ~FILE_NOTIFY_CHANGE_LAST_ACCESS;
5396 if (null_timespec(ft->mtime)) {
5397 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
5400 if (!setting_write_time) {
5401 /* ft->mtime comes from change time, not write time. */
5402 action &= ~FILE_NOTIFY_CHANGE_LAST_WRITE;
5405 if (!conn->hires_timestamps_avail) {
5406 /* We can't store sub second timestamps
5407 * on this share. Round to seconds. */
5408 round_timespec(&ft->create_time);
5409 round_timespec(&ft->ctime);
5410 round_timespec(&ft->atime);
5411 round_timespec(&ft->mtime);
5414 DEBUG(5,("smb_set_filetime: actime: %s\n ",
5415 time_to_asc(convert_timespec_to_time_t(ft->atime))));
5416 DEBUG(5,("smb_set_filetime: modtime: %s\n ",
5417 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5418 DEBUG(5,("smb_set_filetime: ctime: %s\n ",
5419 time_to_asc(convert_timespec_to_time_t(ft->ctime))));
5420 DEBUG(5,("smb_set_file_time: createtime: %s\n ",
5421 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
5423 if (setting_write_time) {
5425 * This was a Windows setfileinfo on an open file.
5426 * NT does this a lot. We also need to
5427 * set the time here, as it can be read by
5428 * FindFirst/FindNext and with the patch for bug #2045
5429 * in smbd/fileio.c it ensures that this timestamp is
5430 * kept sticky even after a write. We save the request
5431 * away and will set it on file close and after a write. JRA.
5434 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
5435 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5438 if (fsp->base_fsp) {
5439 set_sticky_write_time_fsp(fsp->base_fsp,
5442 set_sticky_write_time_fsp(fsp, ft->mtime);
5445 set_sticky_write_time_path(
5446 vfs_file_id_from_sbuf(conn, &smb_fname->st),
5451 DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
5453 /* Always call ntimes on the base, even if a stream was passed in. */
5454 status = create_synthetic_smb_fname(talloc_tos(), smb_fname->base_name,
5455 NULL, &smb_fname->st,
5457 if (!NT_STATUS_IS_OK(status)) {
5461 if(file_ntimes(conn, smb_fname_base, ft)!=0) {
5462 TALLOC_FREE(smb_fname_base);
5463 return map_nt_error_from_unix(errno);
5465 TALLOC_FREE(smb_fname_base);
5467 notify_fname(conn, NOTIFY_ACTION_MODIFIED, action,
5468 smb_fname->base_name);
5469 return NT_STATUS_OK;
5472 /****************************************************************************
5473 Deal with setting the dosmode from any of the setfilepathinfo functions.
5474 ****************************************************************************/
5476 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
5477 const struct smb_filename *smb_fname,
5480 struct smb_filename *smb_fname_base = NULL;
5483 if (!VALID_STAT(smb_fname->st)) {
5484 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5487 /* Always operate on the base_name, even if a stream was passed in. */
5488 status = create_synthetic_smb_fname(talloc_tos(), smb_fname->base_name,
5489 NULL, &smb_fname->st,
5491 if (!NT_STATUS_IS_OK(status)) {
5496 if (S_ISDIR(smb_fname_base->st.st_ex_mode)) {
5503 DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
5505 /* check the mode isn't different, before changing it */
5506 if ((dosmode != 0) && (dosmode != dos_mode(conn, smb_fname_base))) {
5507 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode "
5508 "0x%x\n", smb_fname_str_dbg(smb_fname_base),
5509 (unsigned int)dosmode));
5511 if(file_set_dosmode(conn, smb_fname_base, dosmode, NULL,
5513 DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of "
5515 smb_fname_str_dbg(smb_fname_base),
5517 status = map_nt_error_from_unix(errno);
5521 status = NT_STATUS_OK;
5523 TALLOC_FREE(smb_fname_base);
5527 /****************************************************************************
5528 Deal with setting the size from any of the setfilepathinfo functions.
5529 ****************************************************************************/
5531 static NTSTATUS smb_set_file_size(connection_struct *conn,
5532 struct smb_request *req,
5534 const struct smb_filename *smb_fname,
5535 const SMB_STRUCT_STAT *psbuf,
5538 NTSTATUS status = NT_STATUS_OK;
5539 struct smb_filename *smb_fname_tmp = NULL;
5540 files_struct *new_fsp = NULL;
5542 if (!VALID_STAT(*psbuf)) {
5543 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5546 DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
5548 if (size == get_file_size_stat(psbuf)) {
5549 return NT_STATUS_OK;
5552 DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
5553 smb_fname_str_dbg(smb_fname), (double)size));
5555 if (fsp && fsp->fh->fd != -1) {
5556 /* Handle based call. */
5557 if (vfs_set_filelen(fsp, size) == -1) {
5558 return map_nt_error_from_unix(errno);
5560 trigger_write_time_update_immediate(fsp);
5561 return NT_STATUS_OK;
5564 status = copy_smb_filename(talloc_tos(), smb_fname, &smb_fname_tmp);
5565 if (!NT_STATUS_IS_OK(status)) {
5569 smb_fname_tmp->st = *psbuf;
5571 status = SMB_VFS_CREATE_FILE(
5574 0, /* root_dir_fid */
5575 smb_fname_tmp, /* fname */
5576 FILE_WRITE_ATTRIBUTES, /* access_mask */
5577 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
5579 FILE_OPEN, /* create_disposition*/
5580 0, /* create_options */
5581 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
5582 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
5583 0, /* allocation_size */
5586 &new_fsp, /* result */
5589 TALLOC_FREE(smb_fname_tmp);
5591 if (!NT_STATUS_IS_OK(status)) {
5592 /* NB. We check for open_was_deferred in the caller. */
5596 if (vfs_set_filelen(new_fsp, size) == -1) {
5597 status = map_nt_error_from_unix(errno);
5598 close_file(req, new_fsp,NORMAL_CLOSE);
5602 trigger_write_time_update_immediate(new_fsp);
5603 close_file(req, new_fsp,NORMAL_CLOSE);
5604 return NT_STATUS_OK;
5607 /****************************************************************************
5608 Deal with SMB_INFO_SET_EA.
5609 ****************************************************************************/
5611 static NTSTATUS smb_info_set_ea(connection_struct *conn,
5615 const struct smb_filename *smb_fname)
5617 struct ea_list *ea_list = NULL;
5618 TALLOC_CTX *ctx = NULL;
5619 NTSTATUS status = NT_STATUS_OK;
5621 if (total_data < 10) {
5623 /* OS/2 workplace shell seems to send SET_EA requests of "null"
5624 length. They seem to have no effect. Bug #3212. JRA */
5626 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
5627 /* We're done. We only get EA info in this call. */
5628 return NT_STATUS_OK;
5631 return NT_STATUS_INVALID_PARAMETER;
5634 if (IVAL(pdata,0) > total_data) {
5635 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
5636 IVAL(pdata,0), (unsigned int)total_data));
5637 return NT_STATUS_INVALID_PARAMETER;
5641 ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
5643 return NT_STATUS_INVALID_PARAMETER;
5645 status = set_ea(conn, fsp, smb_fname, ea_list);
5650 /****************************************************************************
5651 Deal with SMB_SET_FILE_DISPOSITION_INFO.
5652 ****************************************************************************/
5654 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
5658 const struct smb_filename *smb_fname)
5660 NTSTATUS status = NT_STATUS_OK;
5661 bool delete_on_close;
5664 if (total_data < 1) {
5665 return NT_STATUS_INVALID_PARAMETER;
5669 return NT_STATUS_INVALID_HANDLE;
5672 delete_on_close = (CVAL(pdata,0) ? True : False);
5673 dosmode = dos_mode(conn, smb_fname);
5675 DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
5676 "delete_on_close = %u\n",
5677 smb_fname_str_dbg(smb_fname),
5678 (unsigned int)dosmode,
5679 (unsigned int)delete_on_close ));
5681 status = can_set_delete_on_close(fsp, delete_on_close, dosmode);
5683 if (!NT_STATUS_IS_OK(status)) {
5687 /* The set is across all open files on this dev/inode pair. */
5688 if (!set_delete_on_close(fsp, delete_on_close,
5689 &conn->server_info->utok)) {
5690 return NT_STATUS_ACCESS_DENIED;
5692 return NT_STATUS_OK;
5695 /****************************************************************************
5696 Deal with SMB_FILE_POSITION_INFORMATION.
5697 ****************************************************************************/
5699 static NTSTATUS smb_file_position_information(connection_struct *conn,
5704 uint64_t position_information;
5706 if (total_data < 8) {
5707 return NT_STATUS_INVALID_PARAMETER;
5711 /* Ignore on pathname based set. */
5712 return NT_STATUS_OK;
5715 position_information = (uint64_t)IVAL(pdata,0);
5716 #ifdef LARGE_SMB_OFF_T
5717 position_information |= (((uint64_t)IVAL(pdata,4)) << 32);
5718 #else /* LARGE_SMB_OFF_T */
5719 if (IVAL(pdata,4) != 0) {
5720 /* more than 32 bits? */
5721 return NT_STATUS_INVALID_PARAMETER;
5723 #endif /* LARGE_SMB_OFF_T */
5725 DEBUG(10,("smb_file_position_information: Set file position "
5726 "information for file %s to %.0f\n", fsp_str_dbg(fsp),
5727 (double)position_information));
5728 fsp->fh->position_information = position_information;
5729 return NT_STATUS_OK;
5732 /****************************************************************************
5733 Deal with SMB_FILE_MODE_INFORMATION.
5734 ****************************************************************************/
5736 static NTSTATUS smb_file_mode_information(connection_struct *conn,
5742 if (total_data < 4) {
5743 return NT_STATUS_INVALID_PARAMETER;
5745 mode = IVAL(pdata,0);
5746 if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
5747 return NT_STATUS_INVALID_PARAMETER;
5749 return NT_STATUS_OK;
5752 /****************************************************************************
5753 Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
5754 ****************************************************************************/
5756 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
5757 struct smb_request *req,
5760 const struct smb_filename *smb_fname)
5762 char *link_target = NULL;
5763 const char *newname = smb_fname->base_name;
5764 NTSTATUS status = NT_STATUS_OK;
5765 TALLOC_CTX *ctx = talloc_tos();
5767 /* Set a symbolic link. */
5768 /* Don't allow this if follow links is false. */
5770 if (total_data == 0) {
5771 return NT_STATUS_INVALID_PARAMETER;
5774 if (!lp_symlinks(SNUM(conn))) {
5775 return NT_STATUS_ACCESS_DENIED;
5778 srvstr_pull_talloc(ctx, pdata, req->flags2, &link_target, pdata,
5779 total_data, STR_TERMINATE);
5782 return NT_STATUS_INVALID_PARAMETER;
5785 /* !widelinks forces the target path to be within the share. */
5786 /* This means we can interpret the target as a pathname. */
5787 if (!lp_widelinks(SNUM(conn))) {
5788 char *rel_name = NULL;
5789 char *last_dirp = NULL;
5791 if (*link_target == '/') {
5792 /* No absolute paths allowed. */
5793 return NT_STATUS_ACCESS_DENIED;
5795 rel_name = talloc_strdup(ctx,newname);
5797 return NT_STATUS_NO_MEMORY;
5799 last_dirp = strrchr_m(rel_name, '/');
5801 last_dirp[1] = '\0';
5803 rel_name = talloc_strdup(ctx,"./");
5805 return NT_STATUS_NO_MEMORY;
5808 rel_name = talloc_asprintf_append(rel_name,
5812 return NT_STATUS_NO_MEMORY;
5815 status = check_name(conn, rel_name);
5816 if (!NT_STATUS_IS_OK(status)) {
5821 DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
5822 newname, link_target ));
5824 if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
5825 return map_nt_error_from_unix(errno);
5828 return NT_STATUS_OK;
5831 /****************************************************************************
5832 Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
5833 ****************************************************************************/
5835 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
5836 struct smb_request *req,
5837 const char *pdata, int total_data,
5838 const struct smb_filename *smb_fname_new)
5840 char *oldname = NULL;
5841 struct smb_filename *smb_fname_old = NULL;
5842 TALLOC_CTX *ctx = talloc_tos();
5843 NTSTATUS status = NT_STATUS_OK;
5845 /* Set a hard link. */
5846 if (total_data == 0) {
5847 return NT_STATUS_INVALID_PARAMETER;
5850 srvstr_get_path(ctx, pdata, req->flags2, &oldname, pdata,
5851 total_data, STR_TERMINATE, &status);
5852 if (!NT_STATUS_IS_OK(status)) {
5856 DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
5857 smb_fname_str_dbg(smb_fname_new), oldname));
5859 status = filename_convert(ctx,
5861 req->flags2 & FLAGS2_DFS_PATHNAMES,
5866 if (!NT_STATUS_IS_OK(status)) {
5870 return hardlink_internals(ctx, conn, smb_fname_old, smb_fname_new);
5873 /****************************************************************************
5874 Deal with SMB_FILE_RENAME_INFORMATION.
5875 ****************************************************************************/
5877 static NTSTATUS smb_file_rename_information(connection_struct *conn,
5878 struct smb_request *req,
5882 struct smb_filename *smb_fname_src)
5887 char *newname = NULL;
5888 struct smb_filename *smb_fname_dst = NULL;
5889 bool dest_has_wcard = False;
5890 NTSTATUS status = NT_STATUS_OK;
5892 TALLOC_CTX *ctx = talloc_tos();
5894 if (total_data < 13) {
5895 return NT_STATUS_INVALID_PARAMETER;
5898 overwrite = (CVAL(pdata,0) ? True : False);
5899 root_fid = IVAL(pdata,4);
5900 len = IVAL(pdata,8);
5902 if (len > (total_data - 12) || (len == 0) || (root_fid != 0)) {
5903 return NT_STATUS_INVALID_PARAMETER;
5906 srvstr_get_path_wcard(ctx, pdata, req->flags2, &newname, &pdata[12],
5909 if (!NT_STATUS_IS_OK(status)) {
5913 DEBUG(10,("smb_file_rename_information: got name |%s|\n",
5916 status = resolve_dfspath_wcard(ctx, conn,
5917 req->flags2 & FLAGS2_DFS_PATHNAMES,
5921 if (!NT_STATUS_IS_OK(status)) {
5925 /* Check the new name has no '/' characters. */
5926 if (strchr_m(newname, '/')) {
5927 return NT_STATUS_NOT_SUPPORTED;
5930 if (fsp && fsp->base_fsp) {
5931 /* newname must be a stream name. */
5932 if (newname[0] != ':') {
5933 return NT_STATUS_NOT_SUPPORTED;
5936 /* Create an smb_fname to call rename_internals_fsp() with. */
5937 status = create_synthetic_smb_fname(talloc_tos(),
5938 fsp->base_fsp->fsp_name->base_name, newname, NULL,
5940 if (!NT_STATUS_IS_OK(status)) {
5945 * Set the original last component, since
5946 * rename_internals_fsp() requires it.
5948 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
5950 if (smb_fname_dst->original_lcomp == NULL) {
5951 status = NT_STATUS_NO_MEMORY;
5957 * Build up an smb_fname_dst based on the filename passed in.
5958 * We basically just strip off the last component, and put on
5959 * the newname instead.
5961 char *base_name = NULL;
5963 /* newname must *not* be a stream name. */
5964 if (newname[0] == ':') {
5965 return NT_STATUS_NOT_SUPPORTED;
5969 * Strip off the last component (filename) of the path passed
5972 base_name = talloc_strdup(ctx, smb_fname_src->base_name);
5974 return NT_STATUS_NO_MEMORY;
5976 p = strrchr_m(base_name, '/');
5980 base_name = talloc_strdup(ctx, "./");
5982 return NT_STATUS_NO_MEMORY;
5985 /* Append the new name. */
5986 base_name = talloc_asprintf_append(base_name,
5990 return NT_STATUS_NO_MEMORY;
5993 status = unix_convert(ctx, conn, base_name, &smb_fname_dst,
5996 UCF_ALWAYS_ALLOW_WCARD_LCOMP :
5999 /* If an error we expect this to be
6000 * NT_STATUS_OBJECT_PATH_NOT_FOUND */
6002 if (!NT_STATUS_IS_OK(status)) {
6003 if(!NT_STATUS_EQUAL(NT_STATUS_OBJECT_PATH_NOT_FOUND,
6007 /* Create an smb_fname to call rename_internals_fsp() */
6008 status = create_synthetic_smb_fname(ctx,
6012 if (!NT_STATUS_IS_OK(status)) {
6019 DEBUG(10,("smb_file_rename_information: "
6020 "SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
6021 fsp->fnum, fsp_str_dbg(fsp),
6022 smb_fname_str_dbg(smb_fname_dst)));
6023 status = rename_internals_fsp(conn, fsp, smb_fname_dst, 0,
6026 DEBUG(10,("smb_file_rename_information: "
6027 "SMB_FILE_RENAME_INFORMATION %s -> %s\n",
6028 smb_fname_str_dbg(smb_fname_src),
6029 smb_fname_str_dbg(smb_fname_dst)));
6030 status = rename_internals(ctx, conn, req, smb_fname_src,
6031 smb_fname_dst, 0, overwrite, false,
6033 FILE_WRITE_ATTRIBUTES);
6036 TALLOC_FREE(smb_fname_dst);
6040 /****************************************************************************
6041 Deal with SMB_SET_POSIX_ACL.
6042 ****************************************************************************/
6044 #if defined(HAVE_POSIX_ACLS)
6045 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
6049 const struct smb_filename *smb_fname)
6051 uint16 posix_acl_version;
6052 uint16 num_file_acls;
6053 uint16 num_def_acls;
6054 bool valid_file_acls = True;
6055 bool valid_def_acls = True;
6057 if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
6058 return NT_STATUS_INVALID_PARAMETER;
6060 posix_acl_version = SVAL(pdata,0);
6061 num_file_acls = SVAL(pdata,2);
6062 num_def_acls = SVAL(pdata,4);
6064 if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6065 valid_file_acls = False;
6069 if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6070 valid_def_acls = False;
6074 if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
6075 return NT_STATUS_INVALID_PARAMETER;
6078 if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
6079 (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
6080 return NT_STATUS_INVALID_PARAMETER;
6083 DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
6084 smb_fname ? smb_fname_str_dbg(smb_fname) : fsp_str_dbg(fsp),
6085 (unsigned int)num_file_acls,
6086 (unsigned int)num_def_acls));
6088 if (valid_file_acls && !set_unix_posix_acl(conn, fsp,
6089 smb_fname->base_name, num_file_acls,
6090 pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
6091 return map_nt_error_from_unix(errno);
6094 if (valid_def_acls && !set_unix_posix_default_acl(conn,
6095 smb_fname->base_name, &smb_fname->st, num_def_acls,
6096 pdata + SMB_POSIX_ACL_HEADER_SIZE +
6097 (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
6098 return map_nt_error_from_unix(errno);
6100 return NT_STATUS_OK;
6104 /****************************************************************************
6105 Deal with SMB_SET_POSIX_LOCK.
6106 ****************************************************************************/
6108 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
6109 struct smb_request *req,
6117 bool blocking_lock = False;
6118 enum brl_type lock_type;
6120 NTSTATUS status = NT_STATUS_OK;
6122 if (fsp == NULL || fsp->fh->fd == -1) {
6123 return NT_STATUS_INVALID_HANDLE;
6126 if (total_data != POSIX_LOCK_DATA_SIZE) {
6127 return NT_STATUS_INVALID_PARAMETER;
6130 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
6131 case POSIX_LOCK_TYPE_READ:
6132 lock_type = READ_LOCK;
6134 case POSIX_LOCK_TYPE_WRITE:
6135 /* Return the right POSIX-mappable error code for files opened read-only. */
6136 if (!fsp->can_write) {
6137 return NT_STATUS_INVALID_HANDLE;
6139 lock_type = WRITE_LOCK;
6141 case POSIX_LOCK_TYPE_UNLOCK:
6142 lock_type = UNLOCK_LOCK;
6145 return NT_STATUS_INVALID_PARAMETER;
6148 if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
6149 blocking_lock = False;
6150 } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
6151 blocking_lock = True;
6153 return NT_STATUS_INVALID_PARAMETER;
6156 if (!lp_blocking_locks(SNUM(conn))) {
6157 blocking_lock = False;
6160 lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
6161 #if defined(HAVE_LONGLONG)
6162 offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
6163 ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
6164 count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
6165 ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
6166 #else /* HAVE_LONGLONG */
6167 offset = (uint64_t)IVAL(pdata,POSIX_LOCK_START_OFFSET);
6168 count = (uint64_t)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
6169 #endif /* HAVE_LONGLONG */
6171 DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
6172 "lock_pid = %u, count = %.0f, offset = %.0f\n",
6174 (unsigned int)lock_type,
6175 (unsigned int)lock_pid,
6179 if (lock_type == UNLOCK_LOCK) {
6180 status = do_unlock(smbd_messaging_context(),
6187 uint32 block_smbpid;
6189 struct byte_range_lock *br_lck = do_lock(smbd_messaging_context(),
6201 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
6203 * A blocking lock was requested. Package up
6204 * this smb into a queued request and push it
6205 * onto the blocking lock queue.
6207 if(push_blocking_lock_request(br_lck,
6210 -1, /* infinite timeout. */
6218 TALLOC_FREE(br_lck);
6222 TALLOC_FREE(br_lck);
6228 /****************************************************************************
6229 Deal with SMB_SET_FILE_BASIC_INFO.
6230 ****************************************************************************/
6232 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
6236 const struct smb_filename *smb_fname)
6238 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
6239 struct smb_file_time ft;
6241 NTSTATUS status = NT_STATUS_OK;
6245 if (total_data < 36) {
6246 return NT_STATUS_INVALID_PARAMETER;
6249 /* Set the attributes */
6250 dosmode = IVAL(pdata,32);
6251 status = smb_set_file_dosmode(conn, smb_fname, dosmode);
6252 if (!NT_STATUS_IS_OK(status)) {
6257 ft.create_time = interpret_long_date(pdata);
6260 ft.atime = interpret_long_date(pdata+8);
6263 ft.mtime = interpret_long_date(pdata+16);
6266 ft.ctime = interpret_long_date(pdata+24);
6268 DEBUG(10, ("smb_set_file_basic_info: file %s\n",
6269 smb_fname_str_dbg(smb_fname)));
6271 return smb_set_file_time(conn, fsp, smb_fname, &ft,
6275 /****************************************************************************
6276 Deal with SMB_INFO_STANDARD.
6277 ****************************************************************************/
6279 static NTSTATUS smb_set_info_standard(connection_struct *conn,
6283 const struct smb_filename *smb_fname)
6285 struct smb_file_time ft;
6289 if (total_data < 12) {
6290 return NT_STATUS_INVALID_PARAMETER;
6294 ft.create_time = convert_time_t_to_timespec(srv_make_unix_date2(pdata));
6296 ft.atime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+4));
6298 ft.mtime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+8));
6300 DEBUG(10,("smb_set_info_standard: file %s\n",
6301 smb_fname_str_dbg(smb_fname)));
6303 return smb_set_file_time(conn,
6310 /****************************************************************************
6311 Deal with SMB_SET_FILE_ALLOCATION_INFO.
6312 ****************************************************************************/
6314 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
6315 struct smb_request *req,
6319 struct smb_filename *smb_fname)
6321 uint64_t allocation_size = 0;
6322 NTSTATUS status = NT_STATUS_OK;
6323 files_struct *new_fsp = NULL;
6325 if (!VALID_STAT(smb_fname->st)) {
6326 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6329 if (total_data < 8) {
6330 return NT_STATUS_INVALID_PARAMETER;
6333 allocation_size = (uint64_t)IVAL(pdata,0);
6334 #ifdef LARGE_SMB_OFF_T
6335 allocation_size |= (((uint64_t)IVAL(pdata,4)) << 32);
6336 #else /* LARGE_SMB_OFF_T */
6337 if (IVAL(pdata,4) != 0) {
6338 /* more than 32 bits? */
6339 return NT_STATUS_INVALID_PARAMETER;
6341 #endif /* LARGE_SMB_OFF_T */
6343 DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for "
6344 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6345 (double)allocation_size));
6347 if (allocation_size) {
6348 allocation_size = smb_roundup(conn, allocation_size);
6351 DEBUG(10,("smb_set_file_allocation_info: file %s : setting new "
6352 "allocation size to %.0f\n", smb_fname_str_dbg(smb_fname),
6353 (double)allocation_size));
6355 if (fsp && fsp->fh->fd != -1) {
6356 /* Open file handle. */
6357 /* Only change if needed. */
6358 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6359 if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
6360 return map_nt_error_from_unix(errno);
6363 /* But always update the time. */
6365 * This is equivalent to a write. Ensure it's seen immediately
6366 * if there are no pending writes.
6368 trigger_write_time_update_immediate(fsp);
6369 return NT_STATUS_OK;
6372 /* Pathname or stat or directory file. */
6373 status = SMB_VFS_CREATE_FILE(
6376 0, /* root_dir_fid */
6377 smb_fname, /* fname */
6378 FILE_WRITE_DATA, /* access_mask */
6379 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
6381 FILE_OPEN, /* create_disposition*/
6382 0, /* create_options */
6383 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
6384 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
6385 0, /* allocation_size */
6388 &new_fsp, /* result */
6391 if (!NT_STATUS_IS_OK(status)) {
6392 /* NB. We check for open_was_deferred in the caller. */
6396 /* Only change if needed. */
6397 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6398 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
6399 status = map_nt_error_from_unix(errno);
6400 close_file(req, new_fsp, NORMAL_CLOSE);
6405 /* Changing the allocation size should set the last mod time. */
6407 * This is equivalent to a write. Ensure it's seen immediately
6408 * if there are no pending writes.
6410 trigger_write_time_update_immediate(new_fsp);
6412 close_file(req, new_fsp, NORMAL_CLOSE);
6413 return NT_STATUS_OK;
6416 /****************************************************************************
6417 Deal with SMB_SET_FILE_END_OF_FILE_INFO.
6418 ****************************************************************************/
6420 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
6421 struct smb_request *req,
6425 const struct smb_filename *smb_fname)
6429 if (total_data < 8) {
6430 return NT_STATUS_INVALID_PARAMETER;
6433 size = IVAL(pdata,0);
6434 #ifdef LARGE_SMB_OFF_T
6435 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
6436 #else /* LARGE_SMB_OFF_T */
6437 if (IVAL(pdata,4) != 0) {
6438 /* more than 32 bits? */
6439 return NT_STATUS_INVALID_PARAMETER;
6441 #endif /* LARGE_SMB_OFF_T */
6442 DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
6443 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6446 return smb_set_file_size(conn, req,
6453 /****************************************************************************
6454 Allow a UNIX info mknod.
6455 ****************************************************************************/
6457 static NTSTATUS smb_unix_mknod(connection_struct *conn,
6460 const struct smb_filename *smb_fname)
6462 uint32 file_type = IVAL(pdata,56);
6463 #if defined(HAVE_MAKEDEV)
6464 uint32 dev_major = IVAL(pdata,60);
6465 uint32 dev_minor = IVAL(pdata,68);
6467 SMB_DEV_T dev = (SMB_DEV_T)0;
6468 uint32 raw_unixmode = IVAL(pdata,84);
6472 if (total_data < 100) {
6473 return NT_STATUS_INVALID_PARAMETER;
6476 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6477 PERM_NEW_FILE, &unixmode);
6478 if (!NT_STATUS_IS_OK(status)) {
6482 #if defined(HAVE_MAKEDEV)
6483 dev = makedev(dev_major, dev_minor);
6486 switch (file_type) {
6487 #if defined(S_IFIFO)
6488 case UNIX_TYPE_FIFO:
6489 unixmode |= S_IFIFO;
6492 #if defined(S_IFSOCK)
6493 case UNIX_TYPE_SOCKET:
6494 unixmode |= S_IFSOCK;
6497 #if defined(S_IFCHR)
6498 case UNIX_TYPE_CHARDEV:
6499 unixmode |= S_IFCHR;
6502 #if defined(S_IFBLK)
6503 case UNIX_TYPE_BLKDEV:
6504 unixmode |= S_IFBLK;
6508 return NT_STATUS_INVALID_PARAMETER;
6511 DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev "
6512 "%.0f mode 0%o for file %s\n", (double)dev,
6513 (unsigned int)unixmode, smb_fname_str_dbg(smb_fname)));
6515 /* Ok - do the mknod. */
6516 if (SMB_VFS_MKNOD(conn, smb_fname->base_name, unixmode, dev) != 0) {
6517 return map_nt_error_from_unix(errno);
6520 /* If any of the other "set" calls fail we
6521 * don't want to end up with a half-constructed mknod.
6524 if (lp_inherit_perms(SNUM(conn))) {
6526 if (!parent_dirname(talloc_tos(), smb_fname->base_name,
6528 return NT_STATUS_NO_MEMORY;
6530 inherit_access_posix_acl(conn, parent, smb_fname->base_name,
6532 TALLOC_FREE(parent);
6535 return NT_STATUS_OK;
6538 /****************************************************************************
6539 Deal with SMB_SET_FILE_UNIX_BASIC.
6540 ****************************************************************************/
6542 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
6543 struct smb_request *req,
6547 const struct smb_filename *smb_fname)
6549 struct smb_file_time ft;
6550 uint32 raw_unixmode;
6553 uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
6554 gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
6555 NTSTATUS status = NT_STATUS_OK;
6556 bool delete_on_fail = False;
6557 enum perm_type ptype;
6558 files_struct *all_fsps = NULL;
6559 bool modify_mtime = true;
6561 SMB_STRUCT_STAT sbuf;
6565 if (total_data < 100) {
6566 return NT_STATUS_INVALID_PARAMETER;
6569 if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
6570 IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
6571 size=IVAL(pdata,0); /* first 8 Bytes are size */
6572 #ifdef LARGE_SMB_OFF_T
6573 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
6574 #else /* LARGE_SMB_OFF_T */
6575 if (IVAL(pdata,4) != 0) {
6576 /* more than 32 bits? */
6577 return NT_STATUS_INVALID_PARAMETER;
6579 #endif /* LARGE_SMB_OFF_T */
6582 ft.atime = interpret_long_date(pdata+24); /* access_time */
6583 ft.mtime = interpret_long_date(pdata+32); /* modification_time */
6584 set_owner = (uid_t)IVAL(pdata,40);
6585 set_grp = (gid_t)IVAL(pdata,48);
6586 raw_unixmode = IVAL(pdata,84);
6588 if (VALID_STAT(smb_fname->st)) {
6589 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
6590 ptype = PERM_EXISTING_DIR;
6592 ptype = PERM_EXISTING_FILE;
6595 ptype = PERM_NEW_FILE;
6598 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6600 if (!NT_STATUS_IS_OK(status)) {
6604 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = "
6605 "%s size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
6606 smb_fname_str_dbg(smb_fname), (double)size,
6607 (unsigned int)set_owner, (unsigned int)set_grp,
6608 (int)raw_unixmode));
6610 sbuf = smb_fname->st;
6612 if (!VALID_STAT(sbuf)) {
6613 struct smb_filename *smb_fname_tmp = NULL;
6615 * The only valid use of this is to create character and block
6616 * devices, and named pipes. This is deprecated (IMHO) and
6617 * a new info level should be used for mknod. JRA.
6620 status = smb_unix_mknod(conn,
6624 if (!NT_STATUS_IS_OK(status)) {
6628 status = copy_smb_filename(talloc_tos(), smb_fname,
6630 if (!NT_STATUS_IS_OK(status)) {
6634 if (SMB_VFS_STAT(conn, smb_fname_tmp) != 0) {
6635 status = map_nt_error_from_unix(errno);
6636 TALLOC_FREE(smb_fname_tmp);
6637 SMB_VFS_UNLINK(conn, smb_fname);
6641 sbuf = smb_fname_tmp->st;
6642 TALLOC_FREE(smb_fname_tmp);
6644 /* Ensure we don't try and change anything else. */
6645 raw_unixmode = SMB_MODE_NO_CHANGE;
6646 size = get_file_size_stat(&sbuf);
6647 ft.atime = sbuf.st_ex_atime;
6648 ft.mtime = sbuf.st_ex_mtime;
6650 * We continue here as we might want to change the
6653 delete_on_fail = True;
6657 /* Horrible backwards compatibility hack as an old server bug
6658 * allowed a CIFS client bug to remain unnoticed :-(. JRA.
6662 size = get_file_size_stat(&sbuf);
6667 * Deal with the UNIX specific mode set.
6670 if (raw_unixmode != SMB_MODE_NO_CHANGE) {
6671 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6672 "setting mode 0%o for file %s\n",
6673 (unsigned int)unixmode,
6674 smb_fname_str_dbg(smb_fname)));
6675 if (SMB_VFS_CHMOD(conn, smb_fname->base_name, unixmode) != 0) {
6676 return map_nt_error_from_unix(errno);
6681 * Deal with the UNIX specific uid set.
6684 if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) &&
6685 (sbuf.st_ex_uid != set_owner)) {
6688 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6689 "changing owner %u for path %s\n",
6690 (unsigned int)set_owner,
6691 smb_fname_str_dbg(smb_fname)));
6693 if (S_ISLNK(sbuf.st_ex_mode)) {
6694 ret = SMB_VFS_LCHOWN(conn, smb_fname->base_name,
6695 set_owner, (gid_t)-1);
6697 ret = SMB_VFS_CHOWN(conn, smb_fname->base_name,
6698 set_owner, (gid_t)-1);
6702 status = map_nt_error_from_unix(errno);
6703 if (delete_on_fail) {
6704 SMB_VFS_UNLINK(conn, smb_fname);
6711 * Deal with the UNIX specific gid set.
6714 if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) &&
6715 (sbuf.st_ex_gid != set_grp)) {
6716 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6717 "changing group %u for file %s\n",
6718 (unsigned int)set_owner,
6719 smb_fname_str_dbg(smb_fname)));
6720 if (SMB_VFS_CHOWN(conn, smb_fname->base_name, (uid_t)-1,
6722 status = map_nt_error_from_unix(errno);
6723 if (delete_on_fail) {
6724 SMB_VFS_UNLINK(conn, smb_fname);
6730 /* Deal with any size changes. */
6732 status = smb_set_file_size(conn, req,
6737 if (!NT_STATUS_IS_OK(status)) {
6741 /* Deal with any time changes. */
6742 if (null_timespec(ft.mtime) && null_timespec(ft.atime)) {
6743 /* No change, don't cancel anything. */
6747 id = vfs_file_id_from_sbuf(conn, &sbuf);
6748 for(all_fsps = file_find_di_first(id); all_fsps;
6749 all_fsps = file_find_di_next(all_fsps)) {
6751 * We're setting the time explicitly for UNIX.
6752 * Cancel any pending changes over all handles.
6754 all_fsps->update_write_time_on_close = false;
6755 TALLOC_FREE(all_fsps->update_write_time_event);
6759 * Override the "setting_write_time"
6760 * parameter here as it almost does what
6761 * we need. Just remember if we modified
6762 * mtime and send the notify ourselves.
6764 if (null_timespec(ft.mtime)) {
6765 modify_mtime = false;
6768 status = smb_set_file_time(conn,
6774 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
6775 FILE_NOTIFY_CHANGE_LAST_WRITE, smb_fname->base_name);
6780 /****************************************************************************
6781 Deal with SMB_SET_FILE_UNIX_INFO2.
6782 ****************************************************************************/
6784 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
6785 struct smb_request *req,
6789 const struct smb_filename *smb_fname)
6795 if (total_data < 116) {
6796 return NT_STATUS_INVALID_PARAMETER;
6799 /* Start by setting all the fields that are common between UNIX_BASIC
6802 status = smb_set_file_unix_basic(conn, req, pdata, total_data,
6804 if (!NT_STATUS_IS_OK(status)) {
6808 smb_fflags = IVAL(pdata, 108);
6809 smb_fmask = IVAL(pdata, 112);
6811 /* NB: We should only attempt to alter the file flags if the client
6812 * sends a non-zero mask.
6814 if (smb_fmask != 0) {
6815 int stat_fflags = 0;
6817 if (!map_info2_flags_to_sbuf(&smb_fname->st, smb_fflags,
6818 smb_fmask, &stat_fflags)) {
6819 /* Client asked to alter a flag we don't understand. */
6820 return NT_STATUS_INVALID_PARAMETER;
6823 if (fsp && fsp->fh->fd != -1) {
6824 /* XXX: we should be using SMB_VFS_FCHFLAGS here. */
6825 return NT_STATUS_NOT_SUPPORTED;
6827 if (SMB_VFS_CHFLAGS(conn, smb_fname->base_name,
6828 stat_fflags) != 0) {
6829 return map_nt_error_from_unix(errno);
6834 /* XXX: need to add support for changing the create_time here. You
6835 * can do this for paths on Darwin with setattrlist(2). The right way
6836 * to hook this up is probably by extending the VFS utimes interface.
6839 return NT_STATUS_OK;
6842 /****************************************************************************
6843 Create a directory with POSIX semantics.
6844 ****************************************************************************/
6846 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
6847 struct smb_request *req,
6850 struct smb_filename *smb_fname,
6851 int *pdata_return_size)
6853 NTSTATUS status = NT_STATUS_OK;
6854 uint32 raw_unixmode = 0;
6855 uint32 mod_unixmode = 0;
6856 mode_t unixmode = (mode_t)0;
6857 files_struct *fsp = NULL;
6858 uint16 info_level_return = 0;
6860 char *pdata = *ppdata;
6862 if (total_data < 18) {
6863 return NT_STATUS_INVALID_PARAMETER;
6866 raw_unixmode = IVAL(pdata,8);
6867 /* Next 4 bytes are not yet defined. */
6869 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6870 PERM_NEW_DIR, &unixmode);
6871 if (!NT_STATUS_IS_OK(status)) {
6875 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
6877 DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
6878 smb_fname_str_dbg(smb_fname), (unsigned int)unixmode));
6880 status = SMB_VFS_CREATE_FILE(
6883 0, /* root_dir_fid */
6884 smb_fname, /* fname */
6885 FILE_READ_ATTRIBUTES, /* access_mask */
6886 FILE_SHARE_NONE, /* share_access */
6887 FILE_CREATE, /* create_disposition*/
6888 FILE_DIRECTORY_FILE, /* create_options */
6889 mod_unixmode, /* file_attributes */
6890 0, /* oplock_request */
6891 0, /* allocation_size */
6897 if (NT_STATUS_IS_OK(status)) {
6898 close_file(req, fsp, NORMAL_CLOSE);
6901 info_level_return = SVAL(pdata,16);
6903 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
6904 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
6905 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
6906 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
6908 *pdata_return_size = 12;
6911 /* Realloc the data size */
6912 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
6913 if (*ppdata == NULL) {
6914 *pdata_return_size = 0;
6915 return NT_STATUS_NO_MEMORY;
6919 SSVAL(pdata,0,NO_OPLOCK_RETURN);
6920 SSVAL(pdata,2,0); /* No fnum. */
6921 SIVAL(pdata,4,info); /* Was directory created. */
6923 switch (info_level_return) {
6924 case SMB_QUERY_FILE_UNIX_BASIC:
6925 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
6926 SSVAL(pdata,10,0); /* Padding. */
6927 store_file_unix_basic(conn, pdata + 12, fsp,
6930 case SMB_QUERY_FILE_UNIX_INFO2:
6931 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
6932 SSVAL(pdata,10,0); /* Padding. */
6933 store_file_unix_basic_info2(conn, pdata + 12, fsp,
6937 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
6938 SSVAL(pdata,10,0); /* Padding. */
6945 /****************************************************************************
6946 Open/Create a file with POSIX semantics.
6947 ****************************************************************************/
6949 static NTSTATUS smb_posix_open(connection_struct *conn,
6950 struct smb_request *req,
6953 struct smb_filename *smb_fname,
6954 int *pdata_return_size)
6956 bool extended_oplock_granted = False;
6957 char *pdata = *ppdata;
6959 uint32 wire_open_mode = 0;
6960 uint32 raw_unixmode = 0;
6961 uint32 mod_unixmode = 0;
6962 uint32 create_disp = 0;
6963 uint32 access_mask = 0;
6964 uint32 create_options = 0;
6965 NTSTATUS status = NT_STATUS_OK;
6966 mode_t unixmode = (mode_t)0;
6967 files_struct *fsp = NULL;
6968 int oplock_request = 0;
6970 uint16 info_level_return = 0;
6972 if (total_data < 18) {
6973 return NT_STATUS_INVALID_PARAMETER;
6976 flags = IVAL(pdata,0);
6977 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
6978 if (oplock_request) {
6979 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
6982 wire_open_mode = IVAL(pdata,4);
6984 if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
6985 return smb_posix_mkdir(conn, req,
6992 switch (wire_open_mode & SMB_ACCMODE) {
6994 access_mask = FILE_READ_DATA;
6997 access_mask = FILE_WRITE_DATA;
7000 access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
7003 DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
7004 (unsigned int)wire_open_mode ));
7005 return NT_STATUS_INVALID_PARAMETER;
7008 wire_open_mode &= ~SMB_ACCMODE;
7010 if((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) == (SMB_O_CREAT | SMB_O_EXCL)) {
7011 create_disp = FILE_CREATE;
7012 } else if((wire_open_mode & (SMB_O_CREAT | SMB_O_TRUNC)) == (SMB_O_CREAT | SMB_O_TRUNC)) {
7013 create_disp = FILE_OVERWRITE_IF;
7014 } else if((wire_open_mode & SMB_O_CREAT) == SMB_O_CREAT) {
7015 create_disp = FILE_OPEN_IF;
7016 } else if ((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL | SMB_O_TRUNC)) == 0) {
7017 create_disp = FILE_OPEN;
7019 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
7020 (unsigned int)wire_open_mode ));
7021 return NT_STATUS_INVALID_PARAMETER;
7024 raw_unixmode = IVAL(pdata,8);
7025 /* Next 4 bytes are not yet defined. */
7027 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7028 (VALID_STAT(smb_fname->st) ?
7029 PERM_EXISTING_FILE : PERM_NEW_FILE),
7032 if (!NT_STATUS_IS_OK(status)) {
7036 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
7038 if (wire_open_mode & SMB_O_SYNC) {
7039 create_options |= FILE_WRITE_THROUGH;
7041 if (wire_open_mode & SMB_O_APPEND) {
7042 access_mask |= FILE_APPEND_DATA;
7044 if (wire_open_mode & SMB_O_DIRECT) {
7045 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
7048 DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
7049 smb_fname_str_dbg(smb_fname),
7050 (unsigned int)wire_open_mode,
7051 (unsigned int)unixmode ));
7053 status = SMB_VFS_CREATE_FILE(
7056 0, /* root_dir_fid */
7057 smb_fname, /* fname */
7058 access_mask, /* access_mask */
7059 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7061 create_disp, /* create_disposition*/
7062 FILE_NON_DIRECTORY_FILE, /* create_options */
7063 mod_unixmode, /* file_attributes */
7064 oplock_request, /* oplock_request */
7065 0, /* allocation_size */
7071 if (!NT_STATUS_IS_OK(status)) {
7075 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
7076 extended_oplock_granted = True;
7079 if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
7080 extended_oplock_granted = True;
7083 info_level_return = SVAL(pdata,16);
7085 /* Allocate the correct return size. */
7087 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
7088 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
7089 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
7090 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
7092 *pdata_return_size = 12;
7095 /* Realloc the data size */
7096 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
7097 if (*ppdata == NULL) {
7098 close_file(req, fsp, ERROR_CLOSE);
7099 *pdata_return_size = 0;
7100 return NT_STATUS_NO_MEMORY;
7104 if (extended_oplock_granted) {
7105 if (flags & REQUEST_BATCH_OPLOCK) {
7106 SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
7108 SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
7110 } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
7111 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
7113 SSVAL(pdata,0,NO_OPLOCK_RETURN);
7116 SSVAL(pdata,2,fsp->fnum);
7117 SIVAL(pdata,4,info); /* Was file created etc. */
7119 switch (info_level_return) {
7120 case SMB_QUERY_FILE_UNIX_BASIC:
7121 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
7122 SSVAL(pdata,10,0); /* padding. */
7123 store_file_unix_basic(conn, pdata + 12, fsp,
7126 case SMB_QUERY_FILE_UNIX_INFO2:
7127 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
7128 SSVAL(pdata,10,0); /* padding. */
7129 store_file_unix_basic_info2(conn, pdata + 12, fsp,
7133 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
7134 SSVAL(pdata,10,0); /* padding. */
7137 return NT_STATUS_OK;
7140 /****************************************************************************
7141 Delete a file with POSIX semantics.
7142 ****************************************************************************/
7144 static NTSTATUS smb_posix_unlink(connection_struct *conn,
7145 struct smb_request *req,
7148 struct smb_filename *smb_fname)
7150 NTSTATUS status = NT_STATUS_OK;
7151 files_struct *fsp = NULL;
7155 int create_options = 0;
7157 struct share_mode_lock *lck = NULL;
7159 if (total_data < 2) {
7160 return NT_STATUS_INVALID_PARAMETER;
7163 flags = SVAL(pdata,0);
7165 if (!VALID_STAT(smb_fname->st)) {
7166 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
7169 if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
7170 !VALID_STAT_OF_DIR(smb_fname->st)) {
7171 return NT_STATUS_NOT_A_DIRECTORY;
7174 DEBUG(10,("smb_posix_unlink: %s %s\n",
7175 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
7176 smb_fname_str_dbg(smb_fname)));
7178 if (VALID_STAT_OF_DIR(smb_fname->st)) {
7179 create_options |= FILE_DIRECTORY_FILE;
7182 status = SMB_VFS_CREATE_FILE(
7185 0, /* root_dir_fid */
7186 smb_fname, /* fname */
7187 DELETE_ACCESS, /* access_mask */
7188 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7190 FILE_OPEN, /* create_disposition*/
7191 create_options, /* create_options */
7192 FILE_FLAG_POSIX_SEMANTICS|0777, /* file_attributes */
7193 0, /* oplock_request */
7194 0, /* allocation_size */
7200 if (!NT_STATUS_IS_OK(status)) {
7205 * Don't lie to client. If we can't really delete due to
7206 * non-POSIX opens return SHARING_VIOLATION.
7209 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
7212 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
7213 "lock for file %s\n", fsp_str_dbg(fsp)));
7214 close_file(req, fsp, NORMAL_CLOSE);
7215 return NT_STATUS_INVALID_PARAMETER;
7219 * See if others still have the file open. If this is the case, then
7220 * don't delete. If all opens are POSIX delete we can set the delete
7221 * on close disposition.
7223 for (i=0; i<lck->num_share_modes; i++) {
7224 struct share_mode_entry *e = &lck->share_modes[i];
7225 if (is_valid_share_mode_entry(e)) {
7226 if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
7229 /* Fail with sharing violation. */
7230 close_file(req, fsp, NORMAL_CLOSE);
7232 return NT_STATUS_SHARING_VIOLATION;
7237 * Set the delete on close.
7239 status = smb_set_file_disposition_info(conn,
7245 if (!NT_STATUS_IS_OK(status)) {
7246 close_file(req, fsp, NORMAL_CLOSE);
7251 return close_file(req, fsp, NORMAL_CLOSE);
7254 NTSTATUS smbd_do_setfilepathinfo(connection_struct *conn,
7255 struct smb_request *req,
7256 TALLOC_CTX *mem_ctx,
7257 uint16_t info_level,
7259 struct smb_filename *smb_fname,
7260 char **ppdata, int total_data,
7263 char *pdata = *ppdata;
7264 NTSTATUS status = NT_STATUS_OK;
7265 int data_return_size = 0;
7269 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
7270 return NT_STATUS_INVALID_LEVEL;
7273 if (!CAN_WRITE(conn)) {
7274 /* Allow POSIX opens. The open path will deny
7275 * any non-readonly opens. */
7276 if (info_level != SMB_POSIX_PATH_OPEN) {
7277 return NT_STATUS_DOS(ERRSRV, ERRaccess);
7281 DEBUG(3,("smbd_do_setfilepathinfo: %s (fnum %d) info_level=%d "
7282 "totdata=%d\n", smb_fname_str_dbg(smb_fname),
7283 fsp ? fsp->fnum : -1, info_level, total_data));
7285 switch (info_level) {
7287 case SMB_INFO_STANDARD:
7289 status = smb_set_info_standard(conn,
7297 case SMB_INFO_SET_EA:
7299 status = smb_info_set_ea(conn,
7307 case SMB_SET_FILE_BASIC_INFO:
7308 case SMB_FILE_BASIC_INFORMATION:
7310 status = smb_set_file_basic_info(conn,
7318 case SMB_FILE_ALLOCATION_INFORMATION:
7319 case SMB_SET_FILE_ALLOCATION_INFO:
7321 status = smb_set_file_allocation_info(conn, req,
7329 case SMB_FILE_END_OF_FILE_INFORMATION:
7330 case SMB_SET_FILE_END_OF_FILE_INFO:
7332 status = smb_set_file_end_of_file_info(conn, req,
7340 case SMB_FILE_DISPOSITION_INFORMATION:
7341 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
7344 /* JRA - We used to just ignore this on a path ?
7345 * Shouldn't this be invalid level on a pathname
7348 if (tran_call != TRANSACT2_SETFILEINFO) {
7349 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
7352 status = smb_set_file_disposition_info(conn,
7360 case SMB_FILE_POSITION_INFORMATION:
7362 status = smb_file_position_information(conn,
7369 /* From tridge Samba4 :
7370 * MODE_INFORMATION in setfileinfo (I have no
7371 * idea what "mode information" on a file is - it takes a value of 0,
7372 * 2, 4 or 6. What could it be?).
7375 case SMB_FILE_MODE_INFORMATION:
7377 status = smb_file_mode_information(conn,
7384 * CIFS UNIX extensions.
7387 case SMB_SET_FILE_UNIX_BASIC:
7389 status = smb_set_file_unix_basic(conn, req,
7397 case SMB_SET_FILE_UNIX_INFO2:
7399 status = smb_set_file_unix_info2(conn, req,
7407 case SMB_SET_FILE_UNIX_LINK:
7410 /* We must have a pathname for this. */
7411 return NT_STATUS_INVALID_LEVEL;
7413 status = smb_set_file_unix_link(conn, req, pdata,
7414 total_data, smb_fname);
7418 case SMB_SET_FILE_UNIX_HLINK:
7421 /* We must have a pathname for this. */
7422 return NT_STATUS_INVALID_LEVEL;
7424 status = smb_set_file_unix_hlink(conn, req,
7430 case SMB_FILE_RENAME_INFORMATION:
7432 status = smb_file_rename_information(conn, req,
7438 #if defined(HAVE_POSIX_ACLS)
7439 case SMB_SET_POSIX_ACL:
7441 status = smb_set_posix_acl(conn,
7450 case SMB_SET_POSIX_LOCK:
7453 return NT_STATUS_INVALID_LEVEL;
7455 status = smb_set_posix_lock(conn, req,
7456 pdata, total_data, fsp);
7460 case SMB_POSIX_PATH_OPEN:
7463 /* We must have a pathname for this. */
7464 return NT_STATUS_INVALID_LEVEL;
7467 status = smb_posix_open(conn, req,
7475 case SMB_POSIX_PATH_UNLINK:
7478 /* We must have a pathname for this. */
7479 return NT_STATUS_INVALID_LEVEL;
7482 status = smb_posix_unlink(conn, req,
7490 return NT_STATUS_INVALID_LEVEL;
7493 if (!NT_STATUS_IS_OK(status)) {
7497 *ret_data_size = data_return_size;
7498 return NT_STATUS_OK;
7501 /****************************************************************************
7502 Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
7503 ****************************************************************************/
7505 static void call_trans2setfilepathinfo(connection_struct *conn,
7506 struct smb_request *req,
7507 unsigned int tran_call,
7508 char **pparams, int total_params,
7509 char **ppdata, int total_data,
7510 unsigned int max_data_bytes)
7512 char *params = *pparams;
7513 char *pdata = *ppdata;
7515 struct smb_filename *smb_fname = NULL;
7516 files_struct *fsp = NULL;
7517 NTSTATUS status = NT_STATUS_OK;
7518 int data_return_size = 0;
7521 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7525 if (tran_call == TRANSACT2_SETFILEINFO) {
7526 if (total_params < 4) {
7527 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7531 fsp = file_fsp(req, SVAL(params,0));
7532 /* Basic check for non-null fsp. */
7533 if (!check_fsp_open(conn, req, fsp)) {
7536 info_level = SVAL(params,2);
7538 status = copy_smb_filename(talloc_tos(), fsp->fsp_name,
7540 if (!NT_STATUS_IS_OK(status)) {
7541 reply_nterror(req, status);
7545 if(fsp->is_directory || fsp->fh->fd == -1) {
7547 * This is actually a SETFILEINFO on a directory
7548 * handle (returned from an NT SMB). NT5.0 seems
7549 * to do this call. JRA.
7551 if (INFO_LEVEL_IS_UNIX(info_level)) {
7552 /* Always do lstat for UNIX calls. */
7553 if (SMB_VFS_LSTAT(conn, smb_fname)) {
7554 DEBUG(3,("call_trans2setfilepathinfo: "
7555 "SMB_VFS_LSTAT of %s failed "
7557 smb_fname_str_dbg(smb_fname),
7559 reply_nterror(req, map_nt_error_from_unix(errno));
7563 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
7564 DEBUG(3,("call_trans2setfilepathinfo: "
7565 "fileinfo of %s failed (%s)\n",
7566 smb_fname_str_dbg(smb_fname),
7568 reply_nterror(req, map_nt_error_from_unix(errno));
7572 } else if (fsp->print_file) {
7574 * Doing a DELETE_ON_CLOSE should cancel a print job.
7576 if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
7577 fsp->fh->private_options |= FILE_DELETE_ON_CLOSE;
7579 DEBUG(3,("call_trans2setfilepathinfo: "
7580 "Cancelling print job (%s)\n",
7584 send_trans2_replies(conn, req, params, 2,
7589 reply_doserror(req, ERRDOS, ERRbadpath);
7594 * Original code - this is an open file.
7596 if (!check_fsp(conn, req, fsp)) {
7600 if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
7601 DEBUG(3,("call_trans2setfilepathinfo: fstat "
7602 "of fnum %d failed (%s)\n", fsp->fnum,
7604 reply_nterror(req, map_nt_error_from_unix(errno));
7612 if (total_params < 7) {
7613 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7617 info_level = SVAL(params,0);
7618 srvstr_get_path(req, params, req->flags2, &fname, ¶ms[6],
7619 total_params - 6, STR_TERMINATE,
7621 if (!NT_STATUS_IS_OK(status)) {
7622 reply_nterror(req, status);
7626 status = filename_convert(req, conn,
7627 req->flags2 & FLAGS2_DFS_PATHNAMES,
7632 if (!NT_STATUS_IS_OK(status)) {
7633 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
7634 reply_botherror(req,
7635 NT_STATUS_PATH_NOT_COVERED,
7636 ERRSRV, ERRbadpath);
7639 reply_nterror(req, status);
7643 if (INFO_LEVEL_IS_UNIX(info_level)) {
7645 * For CIFS UNIX extensions the target name may not exist.
7648 /* Always do lstat for UNIX calls. */
7649 SMB_VFS_LSTAT(conn, smb_fname);
7651 } else if (!VALID_STAT(smb_fname->st) &&
7652 SMB_VFS_STAT(conn, smb_fname)) {
7653 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of "
7655 smb_fname_str_dbg(smb_fname),
7657 reply_nterror(req, map_nt_error_from_unix(errno));
7662 DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d "
7663 "totdata=%d\n", tran_call, smb_fname_str_dbg(smb_fname),
7664 fsp ? fsp->fnum : -1, info_level,total_data));
7666 /* Realloc the parameter size */
7667 *pparams = (char *)SMB_REALLOC(*pparams,2);
7668 if (*pparams == NULL) {
7669 reply_nterror(req, NT_STATUS_NO_MEMORY);
7676 status = smbd_do_setfilepathinfo(conn, req, req,
7682 if (!NT_STATUS_IS_OK(status)) {
7683 if (open_was_deferred(req->mid)) {
7684 /* We have re-scheduled this call. */
7687 if (blocking_lock_was_deferred(req->mid)) {
7688 /* We have re-scheduled this call. */
7691 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
7692 reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
7693 ERRSRV, ERRbadpath);
7696 if (info_level == SMB_POSIX_PATH_OPEN) {
7697 reply_openerror(req, status);
7701 reply_nterror(req, status);
7705 send_trans2_replies(conn, req, params, 2, *ppdata, data_return_size,
7711 /****************************************************************************
7712 Reply to a TRANS2_MKDIR (make directory with extended attributes).
7713 ****************************************************************************/
7715 static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
7716 char **pparams, int total_params,
7717 char **ppdata, int total_data,
7718 unsigned int max_data_bytes)
7720 struct smb_filename *smb_dname = NULL;
7721 char *params = *pparams;
7722 char *pdata = *ppdata;
7723 char *directory = NULL;
7724 NTSTATUS status = NT_STATUS_OK;
7725 struct ea_list *ea_list = NULL;
7726 TALLOC_CTX *ctx = talloc_tos();
7728 if (!CAN_WRITE(conn)) {
7729 reply_doserror(req, ERRSRV, ERRaccess);
7733 if (total_params < 5) {
7734 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7738 srvstr_get_path(ctx, params, req->flags2, &directory, ¶ms[4],
7739 total_params - 4, STR_TERMINATE,
7741 if (!NT_STATUS_IS_OK(status)) {
7742 reply_nterror(req, status);
7746 DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
7748 status = filename_convert(ctx,
7750 req->flags2 & FLAGS2_DFS_PATHNAMES,
7756 if (!NT_STATUS_IS_OK(status)) {
7757 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
7758 reply_botherror(req,
7759 NT_STATUS_PATH_NOT_COVERED,
7760 ERRSRV, ERRbadpath);
7763 reply_nterror(req, status);
7767 /* Any data in this call is an EA list. */
7768 if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
7769 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
7774 * OS/2 workplace shell seems to send SET_EA requests of "null"
7775 * length (4 bytes containing IVAL 4).
7776 * They seem to have no effect. Bug #3212. JRA.
7779 if (total_data != 4) {
7780 if (total_data < 10) {
7781 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7785 if (IVAL(pdata,0) > total_data) {
7786 DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
7787 IVAL(pdata,0), (unsigned int)total_data));
7788 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7792 ea_list = read_ea_list(talloc_tos(), pdata + 4,
7795 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7799 /* If total_data == 4 Windows doesn't care what values
7800 * are placed in that field, it just ignores them.
7801 * The System i QNTC IBM SMB client puts bad values here,
7802 * so ignore them. */
7804 status = create_directory(conn, req, smb_dname);
7806 if (!NT_STATUS_IS_OK(status)) {
7807 reply_nterror(req, status);
7811 /* Try and set any given EA. */
7813 status = set_ea(conn, NULL, smb_dname, ea_list);
7814 if (!NT_STATUS_IS_OK(status)) {
7815 reply_nterror(req, status);
7820 /* Realloc the parameter and data sizes */
7821 *pparams = (char *)SMB_REALLOC(*pparams,2);
7822 if(*pparams == NULL) {
7823 reply_nterror(req, NT_STATUS_NO_MEMORY);
7830 send_trans2_replies(conn, req, params, 2, *ppdata, 0, max_data_bytes);
7833 TALLOC_FREE(smb_dname);
7837 /****************************************************************************
7838 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
7839 We don't actually do this - we just send a null response.
7840 ****************************************************************************/
7842 static void call_trans2findnotifyfirst(connection_struct *conn,
7843 struct smb_request *req,
7844 char **pparams, int total_params,
7845 char **ppdata, int total_data,
7846 unsigned int max_data_bytes)
7848 char *params = *pparams;
7851 if (total_params < 6) {
7852 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7856 info_level = SVAL(params,4);
7857 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
7859 switch (info_level) {
7864 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
7868 /* Realloc the parameter and data sizes */
7869 *pparams = (char *)SMB_REALLOC(*pparams,6);
7870 if (*pparams == NULL) {
7871 reply_nterror(req, NT_STATUS_NO_MEMORY);
7876 SSVAL(params,0,fnf_handle);
7877 SSVAL(params,2,0); /* No changes */
7878 SSVAL(params,4,0); /* No EA errors */
7885 send_trans2_replies(conn, req, params, 6, *ppdata, 0, max_data_bytes);
7890 /****************************************************************************
7891 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
7892 changes). Currently this does nothing.
7893 ****************************************************************************/
7895 static void call_trans2findnotifynext(connection_struct *conn,
7896 struct smb_request *req,
7897 char **pparams, int total_params,
7898 char **ppdata, int total_data,
7899 unsigned int max_data_bytes)
7901 char *params = *pparams;
7903 DEBUG(3,("call_trans2findnotifynext\n"));
7905 /* Realloc the parameter and data sizes */
7906 *pparams = (char *)SMB_REALLOC(*pparams,4);
7907 if (*pparams == NULL) {
7908 reply_nterror(req, NT_STATUS_NO_MEMORY);
7913 SSVAL(params,0,0); /* No changes */
7914 SSVAL(params,2,0); /* No EA errors */
7916 send_trans2_replies(conn, req, params, 4, *ppdata, 0, max_data_bytes);
7921 /****************************************************************************
7922 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
7923 ****************************************************************************/
7925 static void call_trans2getdfsreferral(connection_struct *conn,
7926 struct smb_request *req,
7927 char **pparams, int total_params,
7928 char **ppdata, int total_data,
7929 unsigned int max_data_bytes)
7931 char *params = *pparams;
7932 char *pathname = NULL;
7934 int max_referral_level;
7935 NTSTATUS status = NT_STATUS_OK;
7936 TALLOC_CTX *ctx = talloc_tos();
7938 DEBUG(10,("call_trans2getdfsreferral\n"));
7940 if (total_params < 3) {
7941 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7945 max_referral_level = SVAL(params,0);
7947 if(!lp_host_msdfs()) {
7948 reply_doserror(req, ERRDOS, ERRbadfunc);
7952 srvstr_pull_talloc(ctx, params, req->flags2, &pathname, ¶ms[2],
7953 total_params - 2, STR_TERMINATE);
7955 reply_nterror(req, NT_STATUS_NOT_FOUND);
7958 if((reply_size = setup_dfs_referral(conn, pathname, max_referral_level,
7959 ppdata,&status)) < 0) {
7960 reply_nterror(req, status);
7964 SSVAL(req->inbuf, smb_flg2,
7965 SVAL(req->inbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
7966 send_trans2_replies(conn, req,0,0,*ppdata,reply_size, max_data_bytes);
7971 #define LMCAT_SPL 0x53
7972 #define LMFUNC_GETJOBID 0x60
7974 /****************************************************************************
7975 Reply to a TRANS2_IOCTL - used for OS/2 printing.
7976 ****************************************************************************/
7978 static void call_trans2ioctl(connection_struct *conn,
7979 struct smb_request *req,
7980 char **pparams, int total_params,
7981 char **ppdata, int total_data,
7982 unsigned int max_data_bytes)
7984 char *pdata = *ppdata;
7985 files_struct *fsp = file_fsp(req, SVAL(req->vwv+15, 0));
7987 /* check for an invalid fid before proceeding */
7990 reply_doserror(req, ERRDOS, ERRbadfid);
7994 if ((SVAL(req->vwv+16, 0) == LMCAT_SPL)
7995 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
7996 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
7997 if (*ppdata == NULL) {
7998 reply_nterror(req, NT_STATUS_NO_MEMORY);
8003 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
8004 CAN ACCEPT THIS IN UNICODE. JRA. */
8006 SSVAL(pdata,0,fsp->rap_print_jobid); /* Job number */
8007 srvstr_push(pdata, req->flags2, pdata + 2,
8008 global_myname(), 15,
8009 STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
8010 srvstr_push(pdata, req->flags2, pdata+18,
8011 lp_servicename(SNUM(conn)), 13,
8012 STR_ASCII|STR_TERMINATE); /* Service name */
8013 send_trans2_replies(conn, req, *pparams, 0, *ppdata, 32,
8018 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
8019 reply_doserror(req, ERRSRV, ERRerror);
8022 /****************************************************************************
8023 Reply to a SMBfindclose (stop trans2 directory search).
8024 ****************************************************************************/
8026 void reply_findclose(struct smb_request *req)
8029 struct smbd_server_connection *sconn = smbd_server_conn;
8031 START_PROFILE(SMBfindclose);
8034 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8035 END_PROFILE(SMBfindclose);
8039 dptr_num = SVALS(req->vwv+0, 0);
8041 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
8043 dptr_close(sconn, &dptr_num);
8045 reply_outbuf(req, 0, 0);
8047 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
8049 END_PROFILE(SMBfindclose);
8053 /****************************************************************************
8054 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
8055 ****************************************************************************/
8057 void reply_findnclose(struct smb_request *req)
8061 START_PROFILE(SMBfindnclose);
8064 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8065 END_PROFILE(SMBfindnclose);
8069 dptr_num = SVAL(req->vwv+0, 0);
8071 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
8073 /* We never give out valid handles for a
8074 findnotifyfirst - so any dptr_num is ok here.
8077 reply_outbuf(req, 0, 0);
8079 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
8081 END_PROFILE(SMBfindnclose);
8085 static void handle_trans2(connection_struct *conn, struct smb_request *req,
8086 struct trans_state *state)
8088 if (Protocol >= PROTOCOL_NT1) {
8089 req->flags2 |= 0x40; /* IS_LONG_NAME */
8090 SSVAL(req->inbuf,smb_flg2,req->flags2);
8093 if (conn->encrypt_level == Required && !req->encrypted) {
8094 if (state->call != TRANSACT2_QFSINFO &&
8095 state->call != TRANSACT2_SETFSINFO) {
8096 DEBUG(0,("handle_trans2: encryption required "
8098 (unsigned int)state->call));
8099 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8104 SMB_PERFCOUNT_SET_SUBOP(&req->pcd, state->call);
8106 /* Now we must call the relevant TRANS2 function */
8107 switch(state->call) {
8108 case TRANSACT2_OPEN:
8110 START_PROFILE(Trans2_open);
8111 call_trans2open(conn, req,
8112 &state->param, state->total_param,
8113 &state->data, state->total_data,
8114 state->max_data_return);
8115 END_PROFILE(Trans2_open);
8119 case TRANSACT2_FINDFIRST:
8121 START_PROFILE(Trans2_findfirst);
8122 call_trans2findfirst(conn, req,
8123 &state->param, state->total_param,
8124 &state->data, state->total_data,
8125 state->max_data_return);
8126 END_PROFILE(Trans2_findfirst);
8130 case TRANSACT2_FINDNEXT:
8132 START_PROFILE(Trans2_findnext);
8133 call_trans2findnext(conn, req,
8134 &state->param, state->total_param,
8135 &state->data, state->total_data,
8136 state->max_data_return);
8137 END_PROFILE(Trans2_findnext);
8141 case TRANSACT2_QFSINFO:
8143 START_PROFILE(Trans2_qfsinfo);
8144 call_trans2qfsinfo(conn, req,
8145 &state->param, state->total_param,
8146 &state->data, state->total_data,
8147 state->max_data_return);
8148 END_PROFILE(Trans2_qfsinfo);
8152 case TRANSACT2_SETFSINFO:
8154 START_PROFILE(Trans2_setfsinfo);
8155 call_trans2setfsinfo(conn, req,
8156 &state->param, state->total_param,
8157 &state->data, state->total_data,
8158 state->max_data_return);
8159 END_PROFILE(Trans2_setfsinfo);
8163 case TRANSACT2_QPATHINFO:
8164 case TRANSACT2_QFILEINFO:
8166 START_PROFILE(Trans2_qpathinfo);
8167 call_trans2qfilepathinfo(conn, req, state->call,
8168 &state->param, state->total_param,
8169 &state->data, state->total_data,
8170 state->max_data_return);
8171 END_PROFILE(Trans2_qpathinfo);
8175 case TRANSACT2_SETPATHINFO:
8176 case TRANSACT2_SETFILEINFO:
8178 START_PROFILE(Trans2_setpathinfo);
8179 call_trans2setfilepathinfo(conn, req, state->call,
8180 &state->param, state->total_param,
8181 &state->data, state->total_data,
8182 state->max_data_return);
8183 END_PROFILE(Trans2_setpathinfo);
8187 case TRANSACT2_FINDNOTIFYFIRST:
8189 START_PROFILE(Trans2_findnotifyfirst);
8190 call_trans2findnotifyfirst(conn, req,
8191 &state->param, state->total_param,
8192 &state->data, state->total_data,
8193 state->max_data_return);
8194 END_PROFILE(Trans2_findnotifyfirst);
8198 case TRANSACT2_FINDNOTIFYNEXT:
8200 START_PROFILE(Trans2_findnotifynext);
8201 call_trans2findnotifynext(conn, req,
8202 &state->param, state->total_param,
8203 &state->data, state->total_data,
8204 state->max_data_return);
8205 END_PROFILE(Trans2_findnotifynext);
8209 case TRANSACT2_MKDIR:
8211 START_PROFILE(Trans2_mkdir);
8212 call_trans2mkdir(conn, req,
8213 &state->param, state->total_param,
8214 &state->data, state->total_data,
8215 state->max_data_return);
8216 END_PROFILE(Trans2_mkdir);
8220 case TRANSACT2_GET_DFS_REFERRAL:
8222 START_PROFILE(Trans2_get_dfs_referral);
8223 call_trans2getdfsreferral(conn, req,
8224 &state->param, state->total_param,
8225 &state->data, state->total_data,
8226 state->max_data_return);
8227 END_PROFILE(Trans2_get_dfs_referral);
8231 case TRANSACT2_IOCTL:
8233 START_PROFILE(Trans2_ioctl);
8234 call_trans2ioctl(conn, req,
8235 &state->param, state->total_param,
8236 &state->data, state->total_data,
8237 state->max_data_return);
8238 END_PROFILE(Trans2_ioctl);
8243 /* Error in request */
8244 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
8245 reply_doserror(req, ERRSRV,ERRerror);
8249 /****************************************************************************
8250 Reply to a SMBtrans2.
8251 ****************************************************************************/
8253 void reply_trans2(struct smb_request *req)
8255 connection_struct *conn = req->conn;
8260 unsigned int tran_call;
8261 struct trans_state *state;
8264 START_PROFILE(SMBtrans2);
8266 if (req->wct < 14) {
8267 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8268 END_PROFILE(SMBtrans2);
8272 dsoff = SVAL(req->vwv+12, 0);
8273 dscnt = SVAL(req->vwv+11, 0);
8274 psoff = SVAL(req->vwv+10, 0);
8275 pscnt = SVAL(req->vwv+9, 0);
8276 tran_call = SVAL(req->vwv+14, 0);
8278 result = allow_new_trans(conn->pending_trans, req->mid);
8279 if (!NT_STATUS_IS_OK(result)) {
8280 DEBUG(2, ("Got invalid trans2 request: %s\n",
8281 nt_errstr(result)));
8282 reply_nterror(req, result);
8283 END_PROFILE(SMBtrans2);
8288 switch (tran_call) {
8289 /* List the allowed trans2 calls on IPC$ */
8290 case TRANSACT2_OPEN:
8291 case TRANSACT2_GET_DFS_REFERRAL:
8292 case TRANSACT2_QFILEINFO:
8293 case TRANSACT2_QFSINFO:
8294 case TRANSACT2_SETFSINFO:
8297 reply_doserror(req, ERRSRV, ERRaccess);
8298 END_PROFILE(SMBtrans2);
8303 if ((state = TALLOC_P(conn, struct trans_state)) == NULL) {
8304 DEBUG(0, ("talloc failed\n"));
8305 reply_nterror(req, NT_STATUS_NO_MEMORY);
8306 END_PROFILE(SMBtrans2);
8310 state->cmd = SMBtrans2;
8312 state->mid = req->mid;
8313 state->vuid = req->vuid;
8314 state->setup_count = SVAL(req->vwv+13, 0);
8315 state->setup = NULL;
8316 state->total_param = SVAL(req->vwv+0, 0);
8317 state->param = NULL;
8318 state->total_data = SVAL(req->vwv+1, 0);
8320 state->max_param_return = SVAL(req->vwv+2, 0);
8321 state->max_data_return = SVAL(req->vwv+3, 0);
8322 state->max_setup_return = SVAL(req->vwv+4, 0);
8323 state->close_on_completion = BITSETW(req->vwv+5, 0);
8324 state->one_way = BITSETW(req->vwv+5, 1);
8326 state->call = tran_call;
8328 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
8329 is so as a sanity check */
8330 if (state->setup_count != 1) {
8332 * Need to have rc=0 for ioctl to get job id for OS/2.
8333 * Network printing will fail if function is not successful.
8334 * Similar function in reply.c will be used if protocol
8335 * is LANMAN1.0 instead of LM1.2X002.
8336 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
8337 * outbuf doesn't have to be set(only job id is used).
8339 if ( (state->setup_count == 4)
8340 && (tran_call == TRANSACT2_IOCTL)
8341 && (SVAL(req->vwv+16, 0) == LMCAT_SPL)
8342 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
8343 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
8345 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
8346 DEBUG(2,("Transaction is %d\n",tran_call));
8348 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8349 END_PROFILE(SMBtrans2);
8354 if ((dscnt > state->total_data) || (pscnt > state->total_param))
8357 if (state->total_data) {
8359 if (trans_oob(state->total_data, 0, dscnt)
8360 || trans_oob(smb_len(req->inbuf), dsoff, dscnt)) {
8364 /* Can't use talloc here, the core routines do realloc on the
8365 * params and data. */
8366 state->data = (char *)SMB_MALLOC(state->total_data);
8367 if (state->data == NULL) {
8368 DEBUG(0,("reply_trans2: data malloc fail for %u "
8369 "bytes !\n", (unsigned int)state->total_data));
8371 reply_nterror(req, NT_STATUS_NO_MEMORY);
8372 END_PROFILE(SMBtrans2);
8376 memcpy(state->data,smb_base(req->inbuf)+dsoff,dscnt);
8379 if (state->total_param) {
8381 if (trans_oob(state->total_param, 0, pscnt)
8382 || trans_oob(smb_len(req->inbuf), psoff, pscnt)) {
8386 /* Can't use talloc here, the core routines do realloc on the
8387 * params and data. */
8388 state->param = (char *)SMB_MALLOC(state->total_param);
8389 if (state->param == NULL) {
8390 DEBUG(0,("reply_trans: param malloc fail for %u "
8391 "bytes !\n", (unsigned int)state->total_param));
8392 SAFE_FREE(state->data);
8394 reply_nterror(req, NT_STATUS_NO_MEMORY);
8395 END_PROFILE(SMBtrans2);
8399 memcpy(state->param,smb_base(req->inbuf)+psoff,pscnt);
8402 state->received_data = dscnt;
8403 state->received_param = pscnt;
8405 if ((state->received_param == state->total_param) &&
8406 (state->received_data == state->total_data)) {
8408 handle_trans2(conn, req, state);
8410 SAFE_FREE(state->data);
8411 SAFE_FREE(state->param);
8413 END_PROFILE(SMBtrans2);
8417 DLIST_ADD(conn->pending_trans, state);
8419 /* We need to send an interim response then receive the rest
8420 of the parameter/data bytes */
8421 reply_outbuf(req, 0, 0);
8422 show_msg((char *)req->outbuf);
8423 END_PROFILE(SMBtrans2);
8428 DEBUG(0,("reply_trans2: invalid trans parameters\n"));
8429 SAFE_FREE(state->data);
8430 SAFE_FREE(state->param);
8432 END_PROFILE(SMBtrans2);
8433 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8437 /****************************************************************************
8438 Reply to a SMBtranss2
8439 ****************************************************************************/
8441 void reply_transs2(struct smb_request *req)
8443 connection_struct *conn = req->conn;
8444 unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
8445 struct trans_state *state;
8447 START_PROFILE(SMBtranss2);
8449 show_msg((char *)req->inbuf);
8452 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8453 END_PROFILE(SMBtranss2);
8457 for (state = conn->pending_trans; state != NULL;
8458 state = state->next) {
8459 if (state->mid == req->mid) {
8464 if ((state == NULL) || (state->cmd != SMBtrans2)) {
8465 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8466 END_PROFILE(SMBtranss2);
8470 /* Revise state->total_param and state->total_data in case they have
8471 changed downwards */
8473 if (SVAL(req->vwv+0, 0) < state->total_param)
8474 state->total_param = SVAL(req->vwv+0, 0);
8475 if (SVAL(req->vwv+1, 0) < state->total_data)
8476 state->total_data = SVAL(req->vwv+1, 0);
8478 pcnt = SVAL(req->vwv+2, 0);
8479 poff = SVAL(req->vwv+3, 0);
8480 pdisp = SVAL(req->vwv+4, 0);
8482 dcnt = SVAL(req->vwv+5, 0);
8483 doff = SVAL(req->vwv+6, 0);
8484 ddisp = SVAL(req->vwv+7, 0);
8486 state->received_param += pcnt;
8487 state->received_data += dcnt;
8489 if ((state->received_data > state->total_data) ||
8490 (state->received_param > state->total_param))
8494 if (trans_oob(state->total_param, pdisp, pcnt)
8495 || trans_oob(smb_len(req->inbuf), poff, pcnt)) {
8498 memcpy(state->param+pdisp,smb_base(req->inbuf)+poff,pcnt);
8502 if (trans_oob(state->total_data, ddisp, dcnt)
8503 || trans_oob(smb_len(req->inbuf), doff, dcnt)) {
8506 memcpy(state->data+ddisp, smb_base(req->inbuf)+doff,dcnt);
8509 if ((state->received_param < state->total_param) ||
8510 (state->received_data < state->total_data)) {
8511 END_PROFILE(SMBtranss2);
8515 handle_trans2(conn, req, state);
8517 DLIST_REMOVE(conn->pending_trans, state);
8518 SAFE_FREE(state->data);
8519 SAFE_FREE(state->param);
8522 END_PROFILE(SMBtranss2);
8527 DEBUG(0,("reply_transs2: invalid trans parameters\n"));
8528 DLIST_REMOVE(conn->pending_trans, state);
8529 SAFE_FREE(state->data);
8530 SAFE_FREE(state->param);
8532 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8533 END_PROFILE(SMBtranss2);