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(conn->ts_res,p,create_date_ts); p += 8;
1673 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1674 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1675 put_long_date_timespec(conn->ts_res,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(conn->ts_res,p,create_date_ts); p += 8;
1739 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1740 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1741 put_long_date_timespec(conn->ts_res,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(conn->ts_res,p,create_date_ts); p += 8;
1775 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1776 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1777 put_long_date_timespec(conn->ts_res,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(conn->ts_res,p,create_date_ts); p += 8;
1850 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1851 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1852 put_long_date_timespec(conn->ts_res,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(conn->ts_res,p,create_date_ts); p += 8;
1897 put_long_date_timespec(conn->ts_res,p,adate_ts); p += 8;
1898 put_long_date_timespec(conn->ts_res,p,mdate_ts); p += 8;
1899 put_long_date_timespec(conn->ts_res,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(TIMESTAMP_SET_NT_OR_BETTER, pdata, psbuf->st_ex_ctime); /* Change Time 64 Bit */
3859 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER ,pdata+8, psbuf->st_ex_atime); /* Last access time 64 Bit */
3860 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER, 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(TIMESTAMP_SET_NT_OR_BETTER,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(conn->ts_res,pdata,create_time_ts);
4412 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4413 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4414 put_long_date_timespec(conn->ts_res,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(conn->ts_res,pdata,create_time_ts);
4507 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4508 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4509 put_long_date_timespec(conn->ts_res,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(conn->ts_res,pdata+0x00,create_time_ts);
4539 put_long_date_timespec(conn->ts_res,pdata+0x08,atime_ts);
4540 put_long_date_timespec(conn->ts_res,pdata+0x10,mtime_ts); /* write time */
4541 put_long_date_timespec(conn->ts_res,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(conn->ts_res,pdata,create_time_ts);
4672 put_long_date_timespec(conn->ts_res,pdata+8,atime_ts);
4673 put_long_date_timespec(conn->ts_res,pdata+16,mtime_ts); /* write time */
4674 put_long_date_timespec(conn->ts_res,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 /* Ensure the resolution is the correct for
5406 * what we can store on this filesystem. */
5408 round_timespec(conn->ts_res, &ft->create_time);
5409 round_timespec(conn->ts_res, &ft->ctime);
5410 round_timespec(conn->ts_res, &ft->atime);
5411 round_timespec(conn->ts_res, &ft->mtime);
5413 DEBUG(5,("smb_set_filetime: actime: %s\n ",
5414 time_to_asc(convert_timespec_to_time_t(ft->atime))));
5415 DEBUG(5,("smb_set_filetime: modtime: %s\n ",
5416 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5417 DEBUG(5,("smb_set_filetime: ctime: %s\n ",
5418 time_to_asc(convert_timespec_to_time_t(ft->ctime))));
5419 DEBUG(5,("smb_set_file_time: createtime: %s\n ",
5420 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
5422 if (setting_write_time) {
5424 * This was a Windows setfileinfo on an open file.
5425 * NT does this a lot. We also need to
5426 * set the time here, as it can be read by
5427 * FindFirst/FindNext and with the patch for bug #2045
5428 * in smbd/fileio.c it ensures that this timestamp is
5429 * kept sticky even after a write. We save the request
5430 * away and will set it on file close and after a write. JRA.
5433 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
5434 time_to_asc(convert_timespec_to_time_t(ft->mtime))));
5437 if (fsp->base_fsp) {
5438 set_sticky_write_time_fsp(fsp->base_fsp,
5441 set_sticky_write_time_fsp(fsp, ft->mtime);
5444 set_sticky_write_time_path(
5445 vfs_file_id_from_sbuf(conn, &smb_fname->st),
5450 DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
5452 /* Always call ntimes on the base, even if a stream was passed in. */
5453 status = create_synthetic_smb_fname(talloc_tos(), smb_fname->base_name,
5454 NULL, &smb_fname->st,
5456 if (!NT_STATUS_IS_OK(status)) {
5460 if(file_ntimes(conn, smb_fname_base, ft)!=0) {
5461 TALLOC_FREE(smb_fname_base);
5462 return map_nt_error_from_unix(errno);
5464 TALLOC_FREE(smb_fname_base);
5466 notify_fname(conn, NOTIFY_ACTION_MODIFIED, action,
5467 smb_fname->base_name);
5468 return NT_STATUS_OK;
5471 /****************************************************************************
5472 Deal with setting the dosmode from any of the setfilepathinfo functions.
5473 ****************************************************************************/
5475 static NTSTATUS smb_set_file_dosmode(connection_struct *conn,
5476 const struct smb_filename *smb_fname,
5479 struct smb_filename *smb_fname_base = NULL;
5482 if (!VALID_STAT(smb_fname->st)) {
5483 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5486 /* Always operate on the base_name, even if a stream was passed in. */
5487 status = create_synthetic_smb_fname(talloc_tos(), smb_fname->base_name,
5488 NULL, &smb_fname->st,
5490 if (!NT_STATUS_IS_OK(status)) {
5495 if (S_ISDIR(smb_fname_base->st.st_ex_mode)) {
5502 DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode));
5504 /* check the mode isn't different, before changing it */
5505 if ((dosmode != 0) && (dosmode != dos_mode(conn, smb_fname_base))) {
5506 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode "
5507 "0x%x\n", smb_fname_str_dbg(smb_fname_base),
5508 (unsigned int)dosmode));
5510 if(file_set_dosmode(conn, smb_fname_base, dosmode, NULL,
5512 DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of "
5514 smb_fname_str_dbg(smb_fname_base),
5516 status = map_nt_error_from_unix(errno);
5520 status = NT_STATUS_OK;
5522 TALLOC_FREE(smb_fname_base);
5526 /****************************************************************************
5527 Deal with setting the size from any of the setfilepathinfo functions.
5528 ****************************************************************************/
5530 static NTSTATUS smb_set_file_size(connection_struct *conn,
5531 struct smb_request *req,
5533 const struct smb_filename *smb_fname,
5534 const SMB_STRUCT_STAT *psbuf,
5537 NTSTATUS status = NT_STATUS_OK;
5538 struct smb_filename *smb_fname_tmp = NULL;
5539 files_struct *new_fsp = NULL;
5541 if (!VALID_STAT(*psbuf)) {
5542 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
5545 DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size));
5547 if (size == get_file_size_stat(psbuf)) {
5548 return NT_STATUS_OK;
5551 DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
5552 smb_fname_str_dbg(smb_fname), (double)size));
5554 if (fsp && fsp->fh->fd != -1) {
5555 /* Handle based call. */
5556 if (vfs_set_filelen(fsp, size) == -1) {
5557 return map_nt_error_from_unix(errno);
5559 trigger_write_time_update_immediate(fsp);
5560 return NT_STATUS_OK;
5563 status = copy_smb_filename(talloc_tos(), smb_fname, &smb_fname_tmp);
5564 if (!NT_STATUS_IS_OK(status)) {
5568 smb_fname_tmp->st = *psbuf;
5570 status = SMB_VFS_CREATE_FILE(
5573 0, /* root_dir_fid */
5574 smb_fname_tmp, /* fname */
5575 FILE_WRITE_ATTRIBUTES, /* access_mask */
5576 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
5578 FILE_OPEN, /* create_disposition*/
5579 0, /* create_options */
5580 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
5581 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
5582 0, /* allocation_size */
5585 &new_fsp, /* result */
5588 TALLOC_FREE(smb_fname_tmp);
5590 if (!NT_STATUS_IS_OK(status)) {
5591 /* NB. We check for open_was_deferred in the caller. */
5595 if (vfs_set_filelen(new_fsp, size) == -1) {
5596 status = map_nt_error_from_unix(errno);
5597 close_file(req, new_fsp,NORMAL_CLOSE);
5601 trigger_write_time_update_immediate(new_fsp);
5602 close_file(req, new_fsp,NORMAL_CLOSE);
5603 return NT_STATUS_OK;
5606 /****************************************************************************
5607 Deal with SMB_INFO_SET_EA.
5608 ****************************************************************************/
5610 static NTSTATUS smb_info_set_ea(connection_struct *conn,
5614 const struct smb_filename *smb_fname)
5616 struct ea_list *ea_list = NULL;
5617 TALLOC_CTX *ctx = NULL;
5618 NTSTATUS status = NT_STATUS_OK;
5620 if (total_data < 10) {
5622 /* OS/2 workplace shell seems to send SET_EA requests of "null"
5623 length. They seem to have no effect. Bug #3212. JRA */
5625 if ((total_data == 4) && (IVAL(pdata,0) == 4)) {
5626 /* We're done. We only get EA info in this call. */
5627 return NT_STATUS_OK;
5630 return NT_STATUS_INVALID_PARAMETER;
5633 if (IVAL(pdata,0) > total_data) {
5634 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
5635 IVAL(pdata,0), (unsigned int)total_data));
5636 return NT_STATUS_INVALID_PARAMETER;
5640 ea_list = read_ea_list(ctx, pdata + 4, total_data - 4);
5642 return NT_STATUS_INVALID_PARAMETER;
5644 status = set_ea(conn, fsp, smb_fname, ea_list);
5649 /****************************************************************************
5650 Deal with SMB_SET_FILE_DISPOSITION_INFO.
5651 ****************************************************************************/
5653 static NTSTATUS smb_set_file_disposition_info(connection_struct *conn,
5657 const struct smb_filename *smb_fname)
5659 NTSTATUS status = NT_STATUS_OK;
5660 bool delete_on_close;
5663 if (total_data < 1) {
5664 return NT_STATUS_INVALID_PARAMETER;
5668 return NT_STATUS_INVALID_HANDLE;
5671 delete_on_close = (CVAL(pdata,0) ? True : False);
5672 dosmode = dos_mode(conn, smb_fname);
5674 DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
5675 "delete_on_close = %u\n",
5676 smb_fname_str_dbg(smb_fname),
5677 (unsigned int)dosmode,
5678 (unsigned int)delete_on_close ));
5680 status = can_set_delete_on_close(fsp, delete_on_close, dosmode);
5682 if (!NT_STATUS_IS_OK(status)) {
5686 /* The set is across all open files on this dev/inode pair. */
5687 if (!set_delete_on_close(fsp, delete_on_close,
5688 &conn->server_info->utok)) {
5689 return NT_STATUS_ACCESS_DENIED;
5691 return NT_STATUS_OK;
5694 /****************************************************************************
5695 Deal with SMB_FILE_POSITION_INFORMATION.
5696 ****************************************************************************/
5698 static NTSTATUS smb_file_position_information(connection_struct *conn,
5703 uint64_t position_information;
5705 if (total_data < 8) {
5706 return NT_STATUS_INVALID_PARAMETER;
5710 /* Ignore on pathname based set. */
5711 return NT_STATUS_OK;
5714 position_information = (uint64_t)IVAL(pdata,0);
5715 #ifdef LARGE_SMB_OFF_T
5716 position_information |= (((uint64_t)IVAL(pdata,4)) << 32);
5717 #else /* LARGE_SMB_OFF_T */
5718 if (IVAL(pdata,4) != 0) {
5719 /* more than 32 bits? */
5720 return NT_STATUS_INVALID_PARAMETER;
5722 #endif /* LARGE_SMB_OFF_T */
5724 DEBUG(10,("smb_file_position_information: Set file position "
5725 "information for file %s to %.0f\n", fsp_str_dbg(fsp),
5726 (double)position_information));
5727 fsp->fh->position_information = position_information;
5728 return NT_STATUS_OK;
5731 /****************************************************************************
5732 Deal with SMB_FILE_MODE_INFORMATION.
5733 ****************************************************************************/
5735 static NTSTATUS smb_file_mode_information(connection_struct *conn,
5741 if (total_data < 4) {
5742 return NT_STATUS_INVALID_PARAMETER;
5744 mode = IVAL(pdata,0);
5745 if (mode != 0 && mode != 2 && mode != 4 && mode != 6) {
5746 return NT_STATUS_INVALID_PARAMETER;
5748 return NT_STATUS_OK;
5751 /****************************************************************************
5752 Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
5753 ****************************************************************************/
5755 static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
5756 struct smb_request *req,
5759 const struct smb_filename *smb_fname)
5761 char *link_target = NULL;
5762 const char *newname = smb_fname->base_name;
5763 NTSTATUS status = NT_STATUS_OK;
5764 TALLOC_CTX *ctx = talloc_tos();
5766 /* Set a symbolic link. */
5767 /* Don't allow this if follow links is false. */
5769 if (total_data == 0) {
5770 return NT_STATUS_INVALID_PARAMETER;
5773 if (!lp_symlinks(SNUM(conn))) {
5774 return NT_STATUS_ACCESS_DENIED;
5777 srvstr_pull_talloc(ctx, pdata, req->flags2, &link_target, pdata,
5778 total_data, STR_TERMINATE);
5781 return NT_STATUS_INVALID_PARAMETER;
5784 /* !widelinks forces the target path to be within the share. */
5785 /* This means we can interpret the target as a pathname. */
5786 if (!lp_widelinks(SNUM(conn))) {
5787 char *rel_name = NULL;
5788 char *last_dirp = NULL;
5790 if (*link_target == '/') {
5791 /* No absolute paths allowed. */
5792 return NT_STATUS_ACCESS_DENIED;
5794 rel_name = talloc_strdup(ctx,newname);
5796 return NT_STATUS_NO_MEMORY;
5798 last_dirp = strrchr_m(rel_name, '/');
5800 last_dirp[1] = '\0';
5802 rel_name = talloc_strdup(ctx,"./");
5804 return NT_STATUS_NO_MEMORY;
5807 rel_name = talloc_asprintf_append(rel_name,
5811 return NT_STATUS_NO_MEMORY;
5814 status = check_name(conn, rel_name);
5815 if (!NT_STATUS_IS_OK(status)) {
5820 DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
5821 newname, link_target ));
5823 if (SMB_VFS_SYMLINK(conn,link_target,newname) != 0) {
5824 return map_nt_error_from_unix(errno);
5827 return NT_STATUS_OK;
5830 /****************************************************************************
5831 Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
5832 ****************************************************************************/
5834 static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
5835 struct smb_request *req,
5836 const char *pdata, int total_data,
5837 const struct smb_filename *smb_fname_new)
5839 char *oldname = NULL;
5840 struct smb_filename *smb_fname_old = NULL;
5841 TALLOC_CTX *ctx = talloc_tos();
5842 NTSTATUS status = NT_STATUS_OK;
5844 /* Set a hard link. */
5845 if (total_data == 0) {
5846 return NT_STATUS_INVALID_PARAMETER;
5849 srvstr_get_path(ctx, pdata, req->flags2, &oldname, pdata,
5850 total_data, STR_TERMINATE, &status);
5851 if (!NT_STATUS_IS_OK(status)) {
5855 DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
5856 smb_fname_str_dbg(smb_fname_new), oldname));
5858 status = filename_convert(ctx,
5860 req->flags2 & FLAGS2_DFS_PATHNAMES,
5865 if (!NT_STATUS_IS_OK(status)) {
5869 return hardlink_internals(ctx, conn, smb_fname_old, smb_fname_new);
5872 /****************************************************************************
5873 Deal with SMB_FILE_RENAME_INFORMATION.
5874 ****************************************************************************/
5876 static NTSTATUS smb_file_rename_information(connection_struct *conn,
5877 struct smb_request *req,
5881 struct smb_filename *smb_fname_src)
5886 char *newname = NULL;
5887 struct smb_filename *smb_fname_dst = NULL;
5888 bool dest_has_wcard = False;
5889 NTSTATUS status = NT_STATUS_OK;
5891 TALLOC_CTX *ctx = talloc_tos();
5893 if (total_data < 13) {
5894 return NT_STATUS_INVALID_PARAMETER;
5897 overwrite = (CVAL(pdata,0) ? True : False);
5898 root_fid = IVAL(pdata,4);
5899 len = IVAL(pdata,8);
5901 if (len > (total_data - 12) || (len == 0) || (root_fid != 0)) {
5902 return NT_STATUS_INVALID_PARAMETER;
5905 srvstr_get_path_wcard(ctx, pdata, req->flags2, &newname, &pdata[12],
5908 if (!NT_STATUS_IS_OK(status)) {
5912 DEBUG(10,("smb_file_rename_information: got name |%s|\n",
5915 status = resolve_dfspath_wcard(ctx, conn,
5916 req->flags2 & FLAGS2_DFS_PATHNAMES,
5920 if (!NT_STATUS_IS_OK(status)) {
5924 /* Check the new name has no '/' characters. */
5925 if (strchr_m(newname, '/')) {
5926 return NT_STATUS_NOT_SUPPORTED;
5929 if (fsp && fsp->base_fsp) {
5930 /* newname must be a stream name. */
5931 if (newname[0] != ':') {
5932 return NT_STATUS_NOT_SUPPORTED;
5935 /* Create an smb_fname to call rename_internals_fsp() with. */
5936 status = create_synthetic_smb_fname(talloc_tos(),
5937 fsp->base_fsp->fsp_name->base_name, newname, NULL,
5939 if (!NT_STATUS_IS_OK(status)) {
5944 * Set the original last component, since
5945 * rename_internals_fsp() requires it.
5947 smb_fname_dst->original_lcomp = talloc_strdup(smb_fname_dst,
5949 if (smb_fname_dst->original_lcomp == NULL) {
5950 status = NT_STATUS_NO_MEMORY;
5956 * Build up an smb_fname_dst based on the filename passed in.
5957 * We basically just strip off the last component, and put on
5958 * the newname instead.
5960 char *base_name = NULL;
5962 /* newname must *not* be a stream name. */
5963 if (newname[0] == ':') {
5964 return NT_STATUS_NOT_SUPPORTED;
5968 * Strip off the last component (filename) of the path passed
5971 base_name = talloc_strdup(ctx, smb_fname_src->base_name);
5973 return NT_STATUS_NO_MEMORY;
5975 p = strrchr_m(base_name, '/');
5979 base_name = talloc_strdup(ctx, "./");
5981 return NT_STATUS_NO_MEMORY;
5984 /* Append the new name. */
5985 base_name = talloc_asprintf_append(base_name,
5989 return NT_STATUS_NO_MEMORY;
5992 status = unix_convert(ctx, conn, base_name, &smb_fname_dst,
5995 UCF_ALWAYS_ALLOW_WCARD_LCOMP :
5998 /* If an error we expect this to be
5999 * NT_STATUS_OBJECT_PATH_NOT_FOUND */
6001 if (!NT_STATUS_IS_OK(status)) {
6002 if(!NT_STATUS_EQUAL(NT_STATUS_OBJECT_PATH_NOT_FOUND,
6006 /* Create an smb_fname to call rename_internals_fsp() */
6007 status = create_synthetic_smb_fname(ctx,
6011 if (!NT_STATUS_IS_OK(status)) {
6018 DEBUG(10,("smb_file_rename_information: "
6019 "SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
6020 fsp->fnum, fsp_str_dbg(fsp),
6021 smb_fname_str_dbg(smb_fname_dst)));
6022 status = rename_internals_fsp(conn, fsp, smb_fname_dst, 0,
6025 DEBUG(10,("smb_file_rename_information: "
6026 "SMB_FILE_RENAME_INFORMATION %s -> %s\n",
6027 smb_fname_str_dbg(smb_fname_src),
6028 smb_fname_str_dbg(smb_fname_dst)));
6029 status = rename_internals(ctx, conn, req, smb_fname_src,
6030 smb_fname_dst, 0, overwrite, false,
6032 FILE_WRITE_ATTRIBUTES);
6035 TALLOC_FREE(smb_fname_dst);
6039 /****************************************************************************
6040 Deal with SMB_SET_POSIX_ACL.
6041 ****************************************************************************/
6043 #if defined(HAVE_POSIX_ACLS)
6044 static NTSTATUS smb_set_posix_acl(connection_struct *conn,
6048 const struct smb_filename *smb_fname)
6050 uint16 posix_acl_version;
6051 uint16 num_file_acls;
6052 uint16 num_def_acls;
6053 bool valid_file_acls = True;
6054 bool valid_def_acls = True;
6056 if (total_data < SMB_POSIX_ACL_HEADER_SIZE) {
6057 return NT_STATUS_INVALID_PARAMETER;
6059 posix_acl_version = SVAL(pdata,0);
6060 num_file_acls = SVAL(pdata,2);
6061 num_def_acls = SVAL(pdata,4);
6063 if (num_file_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6064 valid_file_acls = False;
6068 if (num_def_acls == SMB_POSIX_IGNORE_ACE_ENTRIES) {
6069 valid_def_acls = False;
6073 if (posix_acl_version != SMB_POSIX_ACL_VERSION) {
6074 return NT_STATUS_INVALID_PARAMETER;
6077 if (total_data < SMB_POSIX_ACL_HEADER_SIZE +
6078 (num_file_acls+num_def_acls)*SMB_POSIX_ACL_ENTRY_SIZE) {
6079 return NT_STATUS_INVALID_PARAMETER;
6082 DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
6083 smb_fname ? smb_fname_str_dbg(smb_fname) : fsp_str_dbg(fsp),
6084 (unsigned int)num_file_acls,
6085 (unsigned int)num_def_acls));
6087 if (valid_file_acls && !set_unix_posix_acl(conn, fsp,
6088 smb_fname->base_name, num_file_acls,
6089 pdata + SMB_POSIX_ACL_HEADER_SIZE)) {
6090 return map_nt_error_from_unix(errno);
6093 if (valid_def_acls && !set_unix_posix_default_acl(conn,
6094 smb_fname->base_name, &smb_fname->st, num_def_acls,
6095 pdata + SMB_POSIX_ACL_HEADER_SIZE +
6096 (num_file_acls*SMB_POSIX_ACL_ENTRY_SIZE))) {
6097 return map_nt_error_from_unix(errno);
6099 return NT_STATUS_OK;
6103 /****************************************************************************
6104 Deal with SMB_SET_POSIX_LOCK.
6105 ****************************************************************************/
6107 static NTSTATUS smb_set_posix_lock(connection_struct *conn,
6108 struct smb_request *req,
6116 bool blocking_lock = False;
6117 enum brl_type lock_type;
6119 NTSTATUS status = NT_STATUS_OK;
6121 if (fsp == NULL || fsp->fh->fd == -1) {
6122 return NT_STATUS_INVALID_HANDLE;
6125 if (total_data != POSIX_LOCK_DATA_SIZE) {
6126 return NT_STATUS_INVALID_PARAMETER;
6129 switch (SVAL(pdata, POSIX_LOCK_TYPE_OFFSET)) {
6130 case POSIX_LOCK_TYPE_READ:
6131 lock_type = READ_LOCK;
6133 case POSIX_LOCK_TYPE_WRITE:
6134 /* Return the right POSIX-mappable error code for files opened read-only. */
6135 if (!fsp->can_write) {
6136 return NT_STATUS_INVALID_HANDLE;
6138 lock_type = WRITE_LOCK;
6140 case POSIX_LOCK_TYPE_UNLOCK:
6141 lock_type = UNLOCK_LOCK;
6144 return NT_STATUS_INVALID_PARAMETER;
6147 if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_NOWAIT) {
6148 blocking_lock = False;
6149 } else if (SVAL(pdata,POSIX_LOCK_FLAGS_OFFSET) == POSIX_LOCK_FLAG_WAIT) {
6150 blocking_lock = True;
6152 return NT_STATUS_INVALID_PARAMETER;
6155 if (!lp_blocking_locks(SNUM(conn))) {
6156 blocking_lock = False;
6159 lock_pid = IVAL(pdata, POSIX_LOCK_PID_OFFSET);
6160 #if defined(HAVE_LONGLONG)
6161 offset = (((uint64_t) IVAL(pdata,(POSIX_LOCK_START_OFFSET+4))) << 32) |
6162 ((uint64_t) IVAL(pdata,POSIX_LOCK_START_OFFSET));
6163 count = (((uint64_t) IVAL(pdata,(POSIX_LOCK_LEN_OFFSET+4))) << 32) |
6164 ((uint64_t) IVAL(pdata,POSIX_LOCK_LEN_OFFSET));
6165 #else /* HAVE_LONGLONG */
6166 offset = (uint64_t)IVAL(pdata,POSIX_LOCK_START_OFFSET);
6167 count = (uint64_t)IVAL(pdata,POSIX_LOCK_LEN_OFFSET);
6168 #endif /* HAVE_LONGLONG */
6170 DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
6171 "lock_pid = %u, count = %.0f, offset = %.0f\n",
6173 (unsigned int)lock_type,
6174 (unsigned int)lock_pid,
6178 if (lock_type == UNLOCK_LOCK) {
6179 status = do_unlock(smbd_messaging_context(),
6186 uint32 block_smbpid;
6188 struct byte_range_lock *br_lck = do_lock(smbd_messaging_context(),
6200 if (br_lck && blocking_lock && ERROR_WAS_LOCK_DENIED(status)) {
6202 * A blocking lock was requested. Package up
6203 * this smb into a queued request and push it
6204 * onto the blocking lock queue.
6206 if(push_blocking_lock_request(br_lck,
6209 -1, /* infinite timeout. */
6217 TALLOC_FREE(br_lck);
6221 TALLOC_FREE(br_lck);
6227 /****************************************************************************
6228 Deal with SMB_SET_FILE_BASIC_INFO.
6229 ****************************************************************************/
6231 static NTSTATUS smb_set_file_basic_info(connection_struct *conn,
6235 const struct smb_filename *smb_fname)
6237 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
6238 struct smb_file_time ft;
6240 NTSTATUS status = NT_STATUS_OK;
6244 if (total_data < 36) {
6245 return NT_STATUS_INVALID_PARAMETER;
6248 /* Set the attributes */
6249 dosmode = IVAL(pdata,32);
6250 status = smb_set_file_dosmode(conn, smb_fname, dosmode);
6251 if (!NT_STATUS_IS_OK(status)) {
6256 ft.create_time = interpret_long_date(pdata);
6259 ft.atime = interpret_long_date(pdata+8);
6262 ft.mtime = interpret_long_date(pdata+16);
6265 ft.ctime = interpret_long_date(pdata+24);
6267 DEBUG(10, ("smb_set_file_basic_info: file %s\n",
6268 smb_fname_str_dbg(smb_fname)));
6270 return smb_set_file_time(conn, fsp, smb_fname, &ft,
6274 /****************************************************************************
6275 Deal with SMB_INFO_STANDARD.
6276 ****************************************************************************/
6278 static NTSTATUS smb_set_info_standard(connection_struct *conn,
6282 const struct smb_filename *smb_fname)
6284 struct smb_file_time ft;
6288 if (total_data < 12) {
6289 return NT_STATUS_INVALID_PARAMETER;
6293 ft.create_time = convert_time_t_to_timespec(srv_make_unix_date2(pdata));
6295 ft.atime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+4));
6297 ft.mtime = convert_time_t_to_timespec(srv_make_unix_date2(pdata+8));
6299 DEBUG(10,("smb_set_info_standard: file %s\n",
6300 smb_fname_str_dbg(smb_fname)));
6302 return smb_set_file_time(conn,
6309 /****************************************************************************
6310 Deal with SMB_SET_FILE_ALLOCATION_INFO.
6311 ****************************************************************************/
6313 static NTSTATUS smb_set_file_allocation_info(connection_struct *conn,
6314 struct smb_request *req,
6318 struct smb_filename *smb_fname)
6320 uint64_t allocation_size = 0;
6321 NTSTATUS status = NT_STATUS_OK;
6322 files_struct *new_fsp = NULL;
6324 if (!VALID_STAT(smb_fname->st)) {
6325 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
6328 if (total_data < 8) {
6329 return NT_STATUS_INVALID_PARAMETER;
6332 allocation_size = (uint64_t)IVAL(pdata,0);
6333 #ifdef LARGE_SMB_OFF_T
6334 allocation_size |= (((uint64_t)IVAL(pdata,4)) << 32);
6335 #else /* LARGE_SMB_OFF_T */
6336 if (IVAL(pdata,4) != 0) {
6337 /* more than 32 bits? */
6338 return NT_STATUS_INVALID_PARAMETER;
6340 #endif /* LARGE_SMB_OFF_T */
6342 DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for "
6343 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6344 (double)allocation_size));
6346 if (allocation_size) {
6347 allocation_size = smb_roundup(conn, allocation_size);
6350 DEBUG(10,("smb_set_file_allocation_info: file %s : setting new "
6351 "allocation size to %.0f\n", smb_fname_str_dbg(smb_fname),
6352 (double)allocation_size));
6354 if (fsp && fsp->fh->fd != -1) {
6355 /* Open file handle. */
6356 /* Only change if needed. */
6357 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6358 if (vfs_allocate_file_space(fsp, allocation_size) == -1) {
6359 return map_nt_error_from_unix(errno);
6362 /* But always update the time. */
6364 * This is equivalent to a write. Ensure it's seen immediately
6365 * if there are no pending writes.
6367 trigger_write_time_update_immediate(fsp);
6368 return NT_STATUS_OK;
6371 /* Pathname or stat or directory file. */
6372 status = SMB_VFS_CREATE_FILE(
6375 0, /* root_dir_fid */
6376 smb_fname, /* fname */
6377 FILE_WRITE_DATA, /* access_mask */
6378 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
6380 FILE_OPEN, /* create_disposition*/
6381 0, /* create_options */
6382 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
6383 FORCE_OPLOCK_BREAK_TO_NONE, /* oplock_request */
6384 0, /* allocation_size */
6387 &new_fsp, /* result */
6390 if (!NT_STATUS_IS_OK(status)) {
6391 /* NB. We check for open_was_deferred in the caller. */
6395 /* Only change if needed. */
6396 if (allocation_size != get_file_size_stat(&smb_fname->st)) {
6397 if (vfs_allocate_file_space(new_fsp, allocation_size) == -1) {
6398 status = map_nt_error_from_unix(errno);
6399 close_file(req, new_fsp, NORMAL_CLOSE);
6404 /* Changing the allocation size should set the last mod time. */
6406 * This is equivalent to a write. Ensure it's seen immediately
6407 * if there are no pending writes.
6409 trigger_write_time_update_immediate(new_fsp);
6411 close_file(req, new_fsp, NORMAL_CLOSE);
6412 return NT_STATUS_OK;
6415 /****************************************************************************
6416 Deal with SMB_SET_FILE_END_OF_FILE_INFO.
6417 ****************************************************************************/
6419 static NTSTATUS smb_set_file_end_of_file_info(connection_struct *conn,
6420 struct smb_request *req,
6424 const struct smb_filename *smb_fname)
6428 if (total_data < 8) {
6429 return NT_STATUS_INVALID_PARAMETER;
6432 size = IVAL(pdata,0);
6433 #ifdef LARGE_SMB_OFF_T
6434 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
6435 #else /* LARGE_SMB_OFF_T */
6436 if (IVAL(pdata,4) != 0) {
6437 /* more than 32 bits? */
6438 return NT_STATUS_INVALID_PARAMETER;
6440 #endif /* LARGE_SMB_OFF_T */
6441 DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
6442 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname),
6445 return smb_set_file_size(conn, req,
6452 /****************************************************************************
6453 Allow a UNIX info mknod.
6454 ****************************************************************************/
6456 static NTSTATUS smb_unix_mknod(connection_struct *conn,
6459 const struct smb_filename *smb_fname)
6461 uint32 file_type = IVAL(pdata,56);
6462 #if defined(HAVE_MAKEDEV)
6463 uint32 dev_major = IVAL(pdata,60);
6464 uint32 dev_minor = IVAL(pdata,68);
6466 SMB_DEV_T dev = (SMB_DEV_T)0;
6467 uint32 raw_unixmode = IVAL(pdata,84);
6471 if (total_data < 100) {
6472 return NT_STATUS_INVALID_PARAMETER;
6475 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6476 PERM_NEW_FILE, &unixmode);
6477 if (!NT_STATUS_IS_OK(status)) {
6481 #if defined(HAVE_MAKEDEV)
6482 dev = makedev(dev_major, dev_minor);
6485 switch (file_type) {
6486 #if defined(S_IFIFO)
6487 case UNIX_TYPE_FIFO:
6488 unixmode |= S_IFIFO;
6491 #if defined(S_IFSOCK)
6492 case UNIX_TYPE_SOCKET:
6493 unixmode |= S_IFSOCK;
6496 #if defined(S_IFCHR)
6497 case UNIX_TYPE_CHARDEV:
6498 unixmode |= S_IFCHR;
6501 #if defined(S_IFBLK)
6502 case UNIX_TYPE_BLKDEV:
6503 unixmode |= S_IFBLK;
6507 return NT_STATUS_INVALID_PARAMETER;
6510 DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev "
6511 "%.0f mode 0%o for file %s\n", (double)dev,
6512 (unsigned int)unixmode, smb_fname_str_dbg(smb_fname)));
6514 /* Ok - do the mknod. */
6515 if (SMB_VFS_MKNOD(conn, smb_fname->base_name, unixmode, dev) != 0) {
6516 return map_nt_error_from_unix(errno);
6519 /* If any of the other "set" calls fail we
6520 * don't want to end up with a half-constructed mknod.
6523 if (lp_inherit_perms(SNUM(conn))) {
6525 if (!parent_dirname(talloc_tos(), smb_fname->base_name,
6527 return NT_STATUS_NO_MEMORY;
6529 inherit_access_posix_acl(conn, parent, smb_fname->base_name,
6531 TALLOC_FREE(parent);
6534 return NT_STATUS_OK;
6537 /****************************************************************************
6538 Deal with SMB_SET_FILE_UNIX_BASIC.
6539 ****************************************************************************/
6541 static NTSTATUS smb_set_file_unix_basic(connection_struct *conn,
6542 struct smb_request *req,
6546 const struct smb_filename *smb_fname)
6548 struct smb_file_time ft;
6549 uint32 raw_unixmode;
6552 uid_t set_owner = (uid_t)SMB_UID_NO_CHANGE;
6553 gid_t set_grp = (uid_t)SMB_GID_NO_CHANGE;
6554 NTSTATUS status = NT_STATUS_OK;
6555 bool delete_on_fail = False;
6556 enum perm_type ptype;
6557 files_struct *all_fsps = NULL;
6558 bool modify_mtime = true;
6560 SMB_STRUCT_STAT sbuf;
6564 if (total_data < 100) {
6565 return NT_STATUS_INVALID_PARAMETER;
6568 if(IVAL(pdata, 0) != SMB_SIZE_NO_CHANGE_LO &&
6569 IVAL(pdata, 4) != SMB_SIZE_NO_CHANGE_HI) {
6570 size=IVAL(pdata,0); /* first 8 Bytes are size */
6571 #ifdef LARGE_SMB_OFF_T
6572 size |= (((SMB_OFF_T)IVAL(pdata,4)) << 32);
6573 #else /* LARGE_SMB_OFF_T */
6574 if (IVAL(pdata,4) != 0) {
6575 /* more than 32 bits? */
6576 return NT_STATUS_INVALID_PARAMETER;
6578 #endif /* LARGE_SMB_OFF_T */
6581 ft.atime = interpret_long_date(pdata+24); /* access_time */
6582 ft.mtime = interpret_long_date(pdata+32); /* modification_time */
6583 set_owner = (uid_t)IVAL(pdata,40);
6584 set_grp = (gid_t)IVAL(pdata,48);
6585 raw_unixmode = IVAL(pdata,84);
6587 if (VALID_STAT(smb_fname->st)) {
6588 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
6589 ptype = PERM_EXISTING_DIR;
6591 ptype = PERM_EXISTING_FILE;
6594 ptype = PERM_NEW_FILE;
6597 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6599 if (!NT_STATUS_IS_OK(status)) {
6603 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = "
6604 "%s size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
6605 smb_fname_str_dbg(smb_fname), (double)size,
6606 (unsigned int)set_owner, (unsigned int)set_grp,
6607 (int)raw_unixmode));
6609 sbuf = smb_fname->st;
6611 if (!VALID_STAT(sbuf)) {
6612 struct smb_filename *smb_fname_tmp = NULL;
6614 * The only valid use of this is to create character and block
6615 * devices, and named pipes. This is deprecated (IMHO) and
6616 * a new info level should be used for mknod. JRA.
6619 status = smb_unix_mknod(conn,
6623 if (!NT_STATUS_IS_OK(status)) {
6627 status = copy_smb_filename(talloc_tos(), smb_fname,
6629 if (!NT_STATUS_IS_OK(status)) {
6633 if (SMB_VFS_STAT(conn, smb_fname_tmp) != 0) {
6634 status = map_nt_error_from_unix(errno);
6635 TALLOC_FREE(smb_fname_tmp);
6636 SMB_VFS_UNLINK(conn, smb_fname);
6640 sbuf = smb_fname_tmp->st;
6641 TALLOC_FREE(smb_fname_tmp);
6643 /* Ensure we don't try and change anything else. */
6644 raw_unixmode = SMB_MODE_NO_CHANGE;
6645 size = get_file_size_stat(&sbuf);
6646 ft.atime = sbuf.st_ex_atime;
6647 ft.mtime = sbuf.st_ex_mtime;
6649 * We continue here as we might want to change the
6652 delete_on_fail = True;
6656 /* Horrible backwards compatibility hack as an old server bug
6657 * allowed a CIFS client bug to remain unnoticed :-(. JRA.
6661 size = get_file_size_stat(&sbuf);
6666 * Deal with the UNIX specific mode set.
6669 if (raw_unixmode != SMB_MODE_NO_CHANGE) {
6670 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6671 "setting mode 0%o for file %s\n",
6672 (unsigned int)unixmode,
6673 smb_fname_str_dbg(smb_fname)));
6674 if (SMB_VFS_CHMOD(conn, smb_fname->base_name, unixmode) != 0) {
6675 return map_nt_error_from_unix(errno);
6680 * Deal with the UNIX specific uid set.
6683 if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) &&
6684 (sbuf.st_ex_uid != set_owner)) {
6687 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6688 "changing owner %u for path %s\n",
6689 (unsigned int)set_owner,
6690 smb_fname_str_dbg(smb_fname)));
6692 if (S_ISLNK(sbuf.st_ex_mode)) {
6693 ret = SMB_VFS_LCHOWN(conn, smb_fname->base_name,
6694 set_owner, (gid_t)-1);
6696 ret = SMB_VFS_CHOWN(conn, smb_fname->base_name,
6697 set_owner, (gid_t)-1);
6701 status = map_nt_error_from_unix(errno);
6702 if (delete_on_fail) {
6703 SMB_VFS_UNLINK(conn, smb_fname);
6710 * Deal with the UNIX specific gid set.
6713 if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) &&
6714 (sbuf.st_ex_gid != set_grp)) {
6715 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6716 "changing group %u for file %s\n",
6717 (unsigned int)set_owner,
6718 smb_fname_str_dbg(smb_fname)));
6719 if (SMB_VFS_CHOWN(conn, smb_fname->base_name, (uid_t)-1,
6721 status = map_nt_error_from_unix(errno);
6722 if (delete_on_fail) {
6723 SMB_VFS_UNLINK(conn, smb_fname);
6729 /* Deal with any size changes. */
6731 status = smb_set_file_size(conn, req,
6736 if (!NT_STATUS_IS_OK(status)) {
6740 /* Deal with any time changes. */
6741 if (null_timespec(ft.mtime) && null_timespec(ft.atime)) {
6742 /* No change, don't cancel anything. */
6746 id = vfs_file_id_from_sbuf(conn, &sbuf);
6747 for(all_fsps = file_find_di_first(id); all_fsps;
6748 all_fsps = file_find_di_next(all_fsps)) {
6750 * We're setting the time explicitly for UNIX.
6751 * Cancel any pending changes over all handles.
6753 all_fsps->update_write_time_on_close = false;
6754 TALLOC_FREE(all_fsps->update_write_time_event);
6758 * Override the "setting_write_time"
6759 * parameter here as it almost does what
6760 * we need. Just remember if we modified
6761 * mtime and send the notify ourselves.
6763 if (null_timespec(ft.mtime)) {
6764 modify_mtime = false;
6767 status = smb_set_file_time(conn,
6773 notify_fname(conn, NOTIFY_ACTION_MODIFIED,
6774 FILE_NOTIFY_CHANGE_LAST_WRITE, smb_fname->base_name);
6779 /****************************************************************************
6780 Deal with SMB_SET_FILE_UNIX_INFO2.
6781 ****************************************************************************/
6783 static NTSTATUS smb_set_file_unix_info2(connection_struct *conn,
6784 struct smb_request *req,
6788 const struct smb_filename *smb_fname)
6794 if (total_data < 116) {
6795 return NT_STATUS_INVALID_PARAMETER;
6798 /* Start by setting all the fields that are common between UNIX_BASIC
6801 status = smb_set_file_unix_basic(conn, req, pdata, total_data,
6803 if (!NT_STATUS_IS_OK(status)) {
6807 smb_fflags = IVAL(pdata, 108);
6808 smb_fmask = IVAL(pdata, 112);
6810 /* NB: We should only attempt to alter the file flags if the client
6811 * sends a non-zero mask.
6813 if (smb_fmask != 0) {
6814 int stat_fflags = 0;
6816 if (!map_info2_flags_to_sbuf(&smb_fname->st, smb_fflags,
6817 smb_fmask, &stat_fflags)) {
6818 /* Client asked to alter a flag we don't understand. */
6819 return NT_STATUS_INVALID_PARAMETER;
6822 if (fsp && fsp->fh->fd != -1) {
6823 /* XXX: we should be using SMB_VFS_FCHFLAGS here. */
6824 return NT_STATUS_NOT_SUPPORTED;
6826 if (SMB_VFS_CHFLAGS(conn, smb_fname->base_name,
6827 stat_fflags) != 0) {
6828 return map_nt_error_from_unix(errno);
6833 /* XXX: need to add support for changing the create_time here. You
6834 * can do this for paths on Darwin with setattrlist(2). The right way
6835 * to hook this up is probably by extending the VFS utimes interface.
6838 return NT_STATUS_OK;
6841 /****************************************************************************
6842 Create a directory with POSIX semantics.
6843 ****************************************************************************/
6845 static NTSTATUS smb_posix_mkdir(connection_struct *conn,
6846 struct smb_request *req,
6849 struct smb_filename *smb_fname,
6850 int *pdata_return_size)
6852 NTSTATUS status = NT_STATUS_OK;
6853 uint32 raw_unixmode = 0;
6854 uint32 mod_unixmode = 0;
6855 mode_t unixmode = (mode_t)0;
6856 files_struct *fsp = NULL;
6857 uint16 info_level_return = 0;
6859 char *pdata = *ppdata;
6861 if (total_data < 18) {
6862 return NT_STATUS_INVALID_PARAMETER;
6865 raw_unixmode = IVAL(pdata,8);
6866 /* Next 4 bytes are not yet defined. */
6868 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
6869 PERM_NEW_DIR, &unixmode);
6870 if (!NT_STATUS_IS_OK(status)) {
6874 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
6876 DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
6877 smb_fname_str_dbg(smb_fname), (unsigned int)unixmode));
6879 status = SMB_VFS_CREATE_FILE(
6882 0, /* root_dir_fid */
6883 smb_fname, /* fname */
6884 FILE_READ_ATTRIBUTES, /* access_mask */
6885 FILE_SHARE_NONE, /* share_access */
6886 FILE_CREATE, /* create_disposition*/
6887 FILE_DIRECTORY_FILE, /* create_options */
6888 mod_unixmode, /* file_attributes */
6889 0, /* oplock_request */
6890 0, /* allocation_size */
6896 if (NT_STATUS_IS_OK(status)) {
6897 close_file(req, fsp, NORMAL_CLOSE);
6900 info_level_return = SVAL(pdata,16);
6902 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
6903 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
6904 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
6905 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
6907 *pdata_return_size = 12;
6910 /* Realloc the data size */
6911 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
6912 if (*ppdata == NULL) {
6913 *pdata_return_size = 0;
6914 return NT_STATUS_NO_MEMORY;
6918 SSVAL(pdata,0,NO_OPLOCK_RETURN);
6919 SSVAL(pdata,2,0); /* No fnum. */
6920 SIVAL(pdata,4,info); /* Was directory created. */
6922 switch (info_level_return) {
6923 case SMB_QUERY_FILE_UNIX_BASIC:
6924 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
6925 SSVAL(pdata,10,0); /* Padding. */
6926 store_file_unix_basic(conn, pdata + 12, fsp,
6929 case SMB_QUERY_FILE_UNIX_INFO2:
6930 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
6931 SSVAL(pdata,10,0); /* Padding. */
6932 store_file_unix_basic_info2(conn, pdata + 12, fsp,
6936 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
6937 SSVAL(pdata,10,0); /* Padding. */
6944 /****************************************************************************
6945 Open/Create a file with POSIX semantics.
6946 ****************************************************************************/
6948 static NTSTATUS smb_posix_open(connection_struct *conn,
6949 struct smb_request *req,
6952 struct smb_filename *smb_fname,
6953 int *pdata_return_size)
6955 bool extended_oplock_granted = False;
6956 char *pdata = *ppdata;
6958 uint32 wire_open_mode = 0;
6959 uint32 raw_unixmode = 0;
6960 uint32 mod_unixmode = 0;
6961 uint32 create_disp = 0;
6962 uint32 access_mask = 0;
6963 uint32 create_options = 0;
6964 NTSTATUS status = NT_STATUS_OK;
6965 mode_t unixmode = (mode_t)0;
6966 files_struct *fsp = NULL;
6967 int oplock_request = 0;
6969 uint16 info_level_return = 0;
6971 if (total_data < 18) {
6972 return NT_STATUS_INVALID_PARAMETER;
6975 flags = IVAL(pdata,0);
6976 oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
6977 if (oplock_request) {
6978 oplock_request |= (flags & REQUEST_BATCH_OPLOCK) ? BATCH_OPLOCK : 0;
6981 wire_open_mode = IVAL(pdata,4);
6983 if (wire_open_mode == (SMB_O_CREAT|SMB_O_DIRECTORY)) {
6984 return smb_posix_mkdir(conn, req,
6991 switch (wire_open_mode & SMB_ACCMODE) {
6993 access_mask = FILE_READ_DATA;
6996 access_mask = FILE_WRITE_DATA;
6999 access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
7002 DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
7003 (unsigned int)wire_open_mode ));
7004 return NT_STATUS_INVALID_PARAMETER;
7007 wire_open_mode &= ~SMB_ACCMODE;
7009 if((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL)) == (SMB_O_CREAT | SMB_O_EXCL)) {
7010 create_disp = FILE_CREATE;
7011 } else if((wire_open_mode & (SMB_O_CREAT | SMB_O_TRUNC)) == (SMB_O_CREAT | SMB_O_TRUNC)) {
7012 create_disp = FILE_OVERWRITE_IF;
7013 } else if((wire_open_mode & SMB_O_CREAT) == SMB_O_CREAT) {
7014 create_disp = FILE_OPEN_IF;
7015 } else if ((wire_open_mode & (SMB_O_CREAT | SMB_O_EXCL | SMB_O_TRUNC)) == 0) {
7016 create_disp = FILE_OPEN;
7018 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
7019 (unsigned int)wire_open_mode ));
7020 return NT_STATUS_INVALID_PARAMETER;
7023 raw_unixmode = IVAL(pdata,8);
7024 /* Next 4 bytes are not yet defined. */
7026 status = unix_perms_from_wire(conn, &smb_fname->st, raw_unixmode,
7027 (VALID_STAT(smb_fname->st) ?
7028 PERM_EXISTING_FILE : PERM_NEW_FILE),
7031 if (!NT_STATUS_IS_OK(status)) {
7035 mod_unixmode = (uint32)unixmode | FILE_FLAG_POSIX_SEMANTICS;
7037 if (wire_open_mode & SMB_O_SYNC) {
7038 create_options |= FILE_WRITE_THROUGH;
7040 if (wire_open_mode & SMB_O_APPEND) {
7041 access_mask |= FILE_APPEND_DATA;
7043 if (wire_open_mode & SMB_O_DIRECT) {
7044 mod_unixmode |= FILE_FLAG_NO_BUFFERING;
7047 DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
7048 smb_fname_str_dbg(smb_fname),
7049 (unsigned int)wire_open_mode,
7050 (unsigned int)unixmode ));
7052 status = SMB_VFS_CREATE_FILE(
7055 0, /* root_dir_fid */
7056 smb_fname, /* fname */
7057 access_mask, /* access_mask */
7058 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7060 create_disp, /* create_disposition*/
7061 FILE_NON_DIRECTORY_FILE, /* create_options */
7062 mod_unixmode, /* file_attributes */
7063 oplock_request, /* oplock_request */
7064 0, /* allocation_size */
7070 if (!NT_STATUS_IS_OK(status)) {
7074 if (oplock_request && lp_fake_oplocks(SNUM(conn))) {
7075 extended_oplock_granted = True;
7078 if(oplock_request && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
7079 extended_oplock_granted = True;
7082 info_level_return = SVAL(pdata,16);
7084 /* Allocate the correct return size. */
7086 if (info_level_return == SMB_QUERY_FILE_UNIX_BASIC) {
7087 *pdata_return_size = 12 + SMB_FILE_UNIX_BASIC_SIZE;
7088 } else if (info_level_return == SMB_QUERY_FILE_UNIX_INFO2) {
7089 *pdata_return_size = 12 + SMB_FILE_UNIX_INFO2_SIZE;
7091 *pdata_return_size = 12;
7094 /* Realloc the data size */
7095 *ppdata = (char *)SMB_REALLOC(*ppdata,*pdata_return_size);
7096 if (*ppdata == NULL) {
7097 close_file(req, fsp, ERROR_CLOSE);
7098 *pdata_return_size = 0;
7099 return NT_STATUS_NO_MEMORY;
7103 if (extended_oplock_granted) {
7104 if (flags & REQUEST_BATCH_OPLOCK) {
7105 SSVAL(pdata,0, BATCH_OPLOCK_RETURN);
7107 SSVAL(pdata,0, EXCLUSIVE_OPLOCK_RETURN);
7109 } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
7110 SSVAL(pdata,0, LEVEL_II_OPLOCK_RETURN);
7112 SSVAL(pdata,0,NO_OPLOCK_RETURN);
7115 SSVAL(pdata,2,fsp->fnum);
7116 SIVAL(pdata,4,info); /* Was file created etc. */
7118 switch (info_level_return) {
7119 case SMB_QUERY_FILE_UNIX_BASIC:
7120 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_BASIC);
7121 SSVAL(pdata,10,0); /* padding. */
7122 store_file_unix_basic(conn, pdata + 12, fsp,
7125 case SMB_QUERY_FILE_UNIX_INFO2:
7126 SSVAL(pdata,8,SMB_QUERY_FILE_UNIX_INFO2);
7127 SSVAL(pdata,10,0); /* padding. */
7128 store_file_unix_basic_info2(conn, pdata + 12, fsp,
7132 SSVAL(pdata,8,SMB_NO_INFO_LEVEL_RETURNED);
7133 SSVAL(pdata,10,0); /* padding. */
7136 return NT_STATUS_OK;
7139 /****************************************************************************
7140 Delete a file with POSIX semantics.
7141 ****************************************************************************/
7143 static NTSTATUS smb_posix_unlink(connection_struct *conn,
7144 struct smb_request *req,
7147 struct smb_filename *smb_fname)
7149 NTSTATUS status = NT_STATUS_OK;
7150 files_struct *fsp = NULL;
7154 int create_options = 0;
7156 struct share_mode_lock *lck = NULL;
7158 if (total_data < 2) {
7159 return NT_STATUS_INVALID_PARAMETER;
7162 flags = SVAL(pdata,0);
7164 if (!VALID_STAT(smb_fname->st)) {
7165 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
7168 if ((flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) &&
7169 !VALID_STAT_OF_DIR(smb_fname->st)) {
7170 return NT_STATUS_NOT_A_DIRECTORY;
7173 DEBUG(10,("smb_posix_unlink: %s %s\n",
7174 (flags == SMB_POSIX_UNLINK_DIRECTORY_TARGET) ? "directory" : "file",
7175 smb_fname_str_dbg(smb_fname)));
7177 if (VALID_STAT_OF_DIR(smb_fname->st)) {
7178 create_options |= FILE_DIRECTORY_FILE;
7181 status = SMB_VFS_CREATE_FILE(
7184 0, /* root_dir_fid */
7185 smb_fname, /* fname */
7186 DELETE_ACCESS, /* access_mask */
7187 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
7189 FILE_OPEN, /* create_disposition*/
7190 create_options, /* create_options */
7191 FILE_FLAG_POSIX_SEMANTICS|0777, /* file_attributes */
7192 0, /* oplock_request */
7193 0, /* allocation_size */
7199 if (!NT_STATUS_IS_OK(status)) {
7204 * Don't lie to client. If we can't really delete due to
7205 * non-POSIX opens return SHARING_VIOLATION.
7208 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
7211 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
7212 "lock for file %s\n", fsp_str_dbg(fsp)));
7213 close_file(req, fsp, NORMAL_CLOSE);
7214 return NT_STATUS_INVALID_PARAMETER;
7218 * See if others still have the file open. If this is the case, then
7219 * don't delete. If all opens are POSIX delete we can set the delete
7220 * on close disposition.
7222 for (i=0; i<lck->num_share_modes; i++) {
7223 struct share_mode_entry *e = &lck->share_modes[i];
7224 if (is_valid_share_mode_entry(e)) {
7225 if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
7228 /* Fail with sharing violation. */
7229 close_file(req, fsp, NORMAL_CLOSE);
7231 return NT_STATUS_SHARING_VIOLATION;
7236 * Set the delete on close.
7238 status = smb_set_file_disposition_info(conn,
7244 if (!NT_STATUS_IS_OK(status)) {
7245 close_file(req, fsp, NORMAL_CLOSE);
7250 return close_file(req, fsp, NORMAL_CLOSE);
7253 NTSTATUS smbd_do_setfilepathinfo(connection_struct *conn,
7254 struct smb_request *req,
7255 TALLOC_CTX *mem_ctx,
7256 uint16_t info_level,
7258 struct smb_filename *smb_fname,
7259 char **ppdata, int total_data,
7262 char *pdata = *ppdata;
7263 NTSTATUS status = NT_STATUS_OK;
7264 int data_return_size = 0;
7268 if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
7269 return NT_STATUS_INVALID_LEVEL;
7272 if (!CAN_WRITE(conn)) {
7273 /* Allow POSIX opens. The open path will deny
7274 * any non-readonly opens. */
7275 if (info_level != SMB_POSIX_PATH_OPEN) {
7276 return NT_STATUS_DOS(ERRSRV, ERRaccess);
7280 DEBUG(3,("smbd_do_setfilepathinfo: %s (fnum %d) info_level=%d "
7281 "totdata=%d\n", smb_fname_str_dbg(smb_fname),
7282 fsp ? fsp->fnum : -1, info_level, total_data));
7284 switch (info_level) {
7286 case SMB_INFO_STANDARD:
7288 status = smb_set_info_standard(conn,
7296 case SMB_INFO_SET_EA:
7298 status = smb_info_set_ea(conn,
7306 case SMB_SET_FILE_BASIC_INFO:
7307 case SMB_FILE_BASIC_INFORMATION:
7309 status = smb_set_file_basic_info(conn,
7317 case SMB_FILE_ALLOCATION_INFORMATION:
7318 case SMB_SET_FILE_ALLOCATION_INFO:
7320 status = smb_set_file_allocation_info(conn, req,
7328 case SMB_FILE_END_OF_FILE_INFORMATION:
7329 case SMB_SET_FILE_END_OF_FILE_INFO:
7331 status = smb_set_file_end_of_file_info(conn, req,
7339 case SMB_FILE_DISPOSITION_INFORMATION:
7340 case SMB_SET_FILE_DISPOSITION_INFO: /* Set delete on close for open file. */
7343 /* JRA - We used to just ignore this on a path ?
7344 * Shouldn't this be invalid level on a pathname
7347 if (tran_call != TRANSACT2_SETFILEINFO) {
7348 return ERROR_NT(NT_STATUS_INVALID_LEVEL);
7351 status = smb_set_file_disposition_info(conn,
7359 case SMB_FILE_POSITION_INFORMATION:
7361 status = smb_file_position_information(conn,
7368 /* From tridge Samba4 :
7369 * MODE_INFORMATION in setfileinfo (I have no
7370 * idea what "mode information" on a file is - it takes a value of 0,
7371 * 2, 4 or 6. What could it be?).
7374 case SMB_FILE_MODE_INFORMATION:
7376 status = smb_file_mode_information(conn,
7383 * CIFS UNIX extensions.
7386 case SMB_SET_FILE_UNIX_BASIC:
7388 status = smb_set_file_unix_basic(conn, req,
7396 case SMB_SET_FILE_UNIX_INFO2:
7398 status = smb_set_file_unix_info2(conn, req,
7406 case SMB_SET_FILE_UNIX_LINK:
7409 /* We must have a pathname for this. */
7410 return NT_STATUS_INVALID_LEVEL;
7412 status = smb_set_file_unix_link(conn, req, pdata,
7413 total_data, smb_fname);
7417 case SMB_SET_FILE_UNIX_HLINK:
7420 /* We must have a pathname for this. */
7421 return NT_STATUS_INVALID_LEVEL;
7423 status = smb_set_file_unix_hlink(conn, req,
7429 case SMB_FILE_RENAME_INFORMATION:
7431 status = smb_file_rename_information(conn, req,
7437 #if defined(HAVE_POSIX_ACLS)
7438 case SMB_SET_POSIX_ACL:
7440 status = smb_set_posix_acl(conn,
7449 case SMB_SET_POSIX_LOCK:
7452 return NT_STATUS_INVALID_LEVEL;
7454 status = smb_set_posix_lock(conn, req,
7455 pdata, total_data, fsp);
7459 case SMB_POSIX_PATH_OPEN:
7462 /* We must have a pathname for this. */
7463 return NT_STATUS_INVALID_LEVEL;
7466 status = smb_posix_open(conn, req,
7474 case SMB_POSIX_PATH_UNLINK:
7477 /* We must have a pathname for this. */
7478 return NT_STATUS_INVALID_LEVEL;
7481 status = smb_posix_unlink(conn, req,
7489 return NT_STATUS_INVALID_LEVEL;
7492 if (!NT_STATUS_IS_OK(status)) {
7496 *ret_data_size = data_return_size;
7497 return NT_STATUS_OK;
7500 /****************************************************************************
7501 Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
7502 ****************************************************************************/
7504 static void call_trans2setfilepathinfo(connection_struct *conn,
7505 struct smb_request *req,
7506 unsigned int tran_call,
7507 char **pparams, int total_params,
7508 char **ppdata, int total_data,
7509 unsigned int max_data_bytes)
7511 char *params = *pparams;
7512 char *pdata = *ppdata;
7514 struct smb_filename *smb_fname = NULL;
7515 files_struct *fsp = NULL;
7516 NTSTATUS status = NT_STATUS_OK;
7517 int data_return_size = 0;
7520 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7524 if (tran_call == TRANSACT2_SETFILEINFO) {
7525 if (total_params < 4) {
7526 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7530 fsp = file_fsp(req, SVAL(params,0));
7531 /* Basic check for non-null fsp. */
7532 if (!check_fsp_open(conn, req, fsp)) {
7535 info_level = SVAL(params,2);
7537 status = copy_smb_filename(talloc_tos(), fsp->fsp_name,
7539 if (!NT_STATUS_IS_OK(status)) {
7540 reply_nterror(req, status);
7544 if(fsp->is_directory || fsp->fh->fd == -1) {
7546 * This is actually a SETFILEINFO on a directory
7547 * handle (returned from an NT SMB). NT5.0 seems
7548 * to do this call. JRA.
7550 if (INFO_LEVEL_IS_UNIX(info_level)) {
7551 /* Always do lstat for UNIX calls. */
7552 if (SMB_VFS_LSTAT(conn, smb_fname)) {
7553 DEBUG(3,("call_trans2setfilepathinfo: "
7554 "SMB_VFS_LSTAT of %s failed "
7556 smb_fname_str_dbg(smb_fname),
7558 reply_nterror(req, map_nt_error_from_unix(errno));
7562 if (SMB_VFS_STAT(conn, smb_fname) != 0) {
7563 DEBUG(3,("call_trans2setfilepathinfo: "
7564 "fileinfo of %s failed (%s)\n",
7565 smb_fname_str_dbg(smb_fname),
7567 reply_nterror(req, map_nt_error_from_unix(errno));
7571 } else if (fsp->print_file) {
7573 * Doing a DELETE_ON_CLOSE should cancel a print job.
7575 if ((info_level == SMB_SET_FILE_DISPOSITION_INFO) && CVAL(pdata,0)) {
7576 fsp->fh->private_options |= FILE_DELETE_ON_CLOSE;
7578 DEBUG(3,("call_trans2setfilepathinfo: "
7579 "Cancelling print job (%s)\n",
7583 send_trans2_replies(conn, req, params, 2,
7588 reply_doserror(req, ERRDOS, ERRbadpath);
7593 * Original code - this is an open file.
7595 if (!check_fsp(conn, req, fsp)) {
7599 if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
7600 DEBUG(3,("call_trans2setfilepathinfo: fstat "
7601 "of fnum %d failed (%s)\n", fsp->fnum,
7603 reply_nterror(req, map_nt_error_from_unix(errno));
7611 if (total_params < 7) {
7612 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7616 info_level = SVAL(params,0);
7617 srvstr_get_path(req, params, req->flags2, &fname, ¶ms[6],
7618 total_params - 6, STR_TERMINATE,
7620 if (!NT_STATUS_IS_OK(status)) {
7621 reply_nterror(req, status);
7625 status = filename_convert(req, conn,
7626 req->flags2 & FLAGS2_DFS_PATHNAMES,
7631 if (!NT_STATUS_IS_OK(status)) {
7632 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
7633 reply_botherror(req,
7634 NT_STATUS_PATH_NOT_COVERED,
7635 ERRSRV, ERRbadpath);
7638 reply_nterror(req, status);
7642 if (INFO_LEVEL_IS_UNIX(info_level)) {
7644 * For CIFS UNIX extensions the target name may not exist.
7647 /* Always do lstat for UNIX calls. */
7648 SMB_VFS_LSTAT(conn, smb_fname);
7650 } else if (!VALID_STAT(smb_fname->st) &&
7651 SMB_VFS_STAT(conn, smb_fname)) {
7652 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of "
7654 smb_fname_str_dbg(smb_fname),
7656 reply_nterror(req, map_nt_error_from_unix(errno));
7661 DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d "
7662 "totdata=%d\n", tran_call, smb_fname_str_dbg(smb_fname),
7663 fsp ? fsp->fnum : -1, info_level,total_data));
7665 /* Realloc the parameter size */
7666 *pparams = (char *)SMB_REALLOC(*pparams,2);
7667 if (*pparams == NULL) {
7668 reply_nterror(req, NT_STATUS_NO_MEMORY);
7675 status = smbd_do_setfilepathinfo(conn, req, req,
7681 if (!NT_STATUS_IS_OK(status)) {
7682 if (open_was_deferred(req->mid)) {
7683 /* We have re-scheduled this call. */
7686 if (blocking_lock_was_deferred(req->mid)) {
7687 /* We have re-scheduled this call. */
7690 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
7691 reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
7692 ERRSRV, ERRbadpath);
7695 if (info_level == SMB_POSIX_PATH_OPEN) {
7696 reply_openerror(req, status);
7700 reply_nterror(req, status);
7704 send_trans2_replies(conn, req, params, 2, *ppdata, data_return_size,
7710 /****************************************************************************
7711 Reply to a TRANS2_MKDIR (make directory with extended attributes).
7712 ****************************************************************************/
7714 static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
7715 char **pparams, int total_params,
7716 char **ppdata, int total_data,
7717 unsigned int max_data_bytes)
7719 struct smb_filename *smb_dname = NULL;
7720 char *params = *pparams;
7721 char *pdata = *ppdata;
7722 char *directory = NULL;
7723 NTSTATUS status = NT_STATUS_OK;
7724 struct ea_list *ea_list = NULL;
7725 TALLOC_CTX *ctx = talloc_tos();
7727 if (!CAN_WRITE(conn)) {
7728 reply_doserror(req, ERRSRV, ERRaccess);
7732 if (total_params < 5) {
7733 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7737 srvstr_get_path(ctx, params, req->flags2, &directory, ¶ms[4],
7738 total_params - 4, STR_TERMINATE,
7740 if (!NT_STATUS_IS_OK(status)) {
7741 reply_nterror(req, status);
7745 DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
7747 status = filename_convert(ctx,
7749 req->flags2 & FLAGS2_DFS_PATHNAMES,
7755 if (!NT_STATUS_IS_OK(status)) {
7756 if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
7757 reply_botherror(req,
7758 NT_STATUS_PATH_NOT_COVERED,
7759 ERRSRV, ERRbadpath);
7762 reply_nterror(req, status);
7766 /* Any data in this call is an EA list. */
7767 if (total_data && (total_data != 4) && !lp_ea_support(SNUM(conn))) {
7768 reply_nterror(req, NT_STATUS_EAS_NOT_SUPPORTED);
7773 * OS/2 workplace shell seems to send SET_EA requests of "null"
7774 * length (4 bytes containing IVAL 4).
7775 * They seem to have no effect. Bug #3212. JRA.
7778 if (total_data != 4) {
7779 if (total_data < 10) {
7780 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7784 if (IVAL(pdata,0) > total_data) {
7785 DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
7786 IVAL(pdata,0), (unsigned int)total_data));
7787 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7791 ea_list = read_ea_list(talloc_tos(), pdata + 4,
7794 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7798 /* If total_data == 4 Windows doesn't care what values
7799 * are placed in that field, it just ignores them.
7800 * The System i QNTC IBM SMB client puts bad values here,
7801 * so ignore them. */
7803 status = create_directory(conn, req, smb_dname);
7805 if (!NT_STATUS_IS_OK(status)) {
7806 reply_nterror(req, status);
7810 /* Try and set any given EA. */
7812 status = set_ea(conn, NULL, smb_dname, ea_list);
7813 if (!NT_STATUS_IS_OK(status)) {
7814 reply_nterror(req, status);
7819 /* Realloc the parameter and data sizes */
7820 *pparams = (char *)SMB_REALLOC(*pparams,2);
7821 if(*pparams == NULL) {
7822 reply_nterror(req, NT_STATUS_NO_MEMORY);
7829 send_trans2_replies(conn, req, params, 2, *ppdata, 0, max_data_bytes);
7832 TALLOC_FREE(smb_dname);
7836 /****************************************************************************
7837 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
7838 We don't actually do this - we just send a null response.
7839 ****************************************************************************/
7841 static void call_trans2findnotifyfirst(connection_struct *conn,
7842 struct smb_request *req,
7843 char **pparams, int total_params,
7844 char **ppdata, int total_data,
7845 unsigned int max_data_bytes)
7847 char *params = *pparams;
7850 if (total_params < 6) {
7851 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7855 info_level = SVAL(params,4);
7856 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level));
7858 switch (info_level) {
7863 reply_nterror(req, NT_STATUS_INVALID_LEVEL);
7867 /* Realloc the parameter and data sizes */
7868 *pparams = (char *)SMB_REALLOC(*pparams,6);
7869 if (*pparams == NULL) {
7870 reply_nterror(req, NT_STATUS_NO_MEMORY);
7875 SSVAL(params,0,fnf_handle);
7876 SSVAL(params,2,0); /* No changes */
7877 SSVAL(params,4,0); /* No EA errors */
7884 send_trans2_replies(conn, req, params, 6, *ppdata, 0, max_data_bytes);
7889 /****************************************************************************
7890 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
7891 changes). Currently this does nothing.
7892 ****************************************************************************/
7894 static void call_trans2findnotifynext(connection_struct *conn,
7895 struct smb_request *req,
7896 char **pparams, int total_params,
7897 char **ppdata, int total_data,
7898 unsigned int max_data_bytes)
7900 char *params = *pparams;
7902 DEBUG(3,("call_trans2findnotifynext\n"));
7904 /* Realloc the parameter and data sizes */
7905 *pparams = (char *)SMB_REALLOC(*pparams,4);
7906 if (*pparams == NULL) {
7907 reply_nterror(req, NT_STATUS_NO_MEMORY);
7912 SSVAL(params,0,0); /* No changes */
7913 SSVAL(params,2,0); /* No EA errors */
7915 send_trans2_replies(conn, req, params, 4, *ppdata, 0, max_data_bytes);
7920 /****************************************************************************
7921 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
7922 ****************************************************************************/
7924 static void call_trans2getdfsreferral(connection_struct *conn,
7925 struct smb_request *req,
7926 char **pparams, int total_params,
7927 char **ppdata, int total_data,
7928 unsigned int max_data_bytes)
7930 char *params = *pparams;
7931 char *pathname = NULL;
7933 int max_referral_level;
7934 NTSTATUS status = NT_STATUS_OK;
7935 TALLOC_CTX *ctx = talloc_tos();
7937 DEBUG(10,("call_trans2getdfsreferral\n"));
7939 if (total_params < 3) {
7940 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
7944 max_referral_level = SVAL(params,0);
7946 if(!lp_host_msdfs()) {
7947 reply_doserror(req, ERRDOS, ERRbadfunc);
7951 srvstr_pull_talloc(ctx, params, req->flags2, &pathname, ¶ms[2],
7952 total_params - 2, STR_TERMINATE);
7954 reply_nterror(req, NT_STATUS_NOT_FOUND);
7957 if((reply_size = setup_dfs_referral(conn, pathname, max_referral_level,
7958 ppdata,&status)) < 0) {
7959 reply_nterror(req, status);
7963 SSVAL(req->inbuf, smb_flg2,
7964 SVAL(req->inbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
7965 send_trans2_replies(conn, req,0,0,*ppdata,reply_size, max_data_bytes);
7970 #define LMCAT_SPL 0x53
7971 #define LMFUNC_GETJOBID 0x60
7973 /****************************************************************************
7974 Reply to a TRANS2_IOCTL - used for OS/2 printing.
7975 ****************************************************************************/
7977 static void call_trans2ioctl(connection_struct *conn,
7978 struct smb_request *req,
7979 char **pparams, int total_params,
7980 char **ppdata, int total_data,
7981 unsigned int max_data_bytes)
7983 char *pdata = *ppdata;
7984 files_struct *fsp = file_fsp(req, SVAL(req->vwv+15, 0));
7986 /* check for an invalid fid before proceeding */
7989 reply_doserror(req, ERRDOS, ERRbadfid);
7993 if ((SVAL(req->vwv+16, 0) == LMCAT_SPL)
7994 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
7995 *ppdata = (char *)SMB_REALLOC(*ppdata, 32);
7996 if (*ppdata == NULL) {
7997 reply_nterror(req, NT_STATUS_NO_MEMORY);
8002 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
8003 CAN ACCEPT THIS IN UNICODE. JRA. */
8005 SSVAL(pdata,0,fsp->rap_print_jobid); /* Job number */
8006 srvstr_push(pdata, req->flags2, pdata + 2,
8007 global_myname(), 15,
8008 STR_ASCII|STR_TERMINATE); /* Our NetBIOS name */
8009 srvstr_push(pdata, req->flags2, pdata+18,
8010 lp_servicename(SNUM(conn)), 13,
8011 STR_ASCII|STR_TERMINATE); /* Service name */
8012 send_trans2_replies(conn, req, *pparams, 0, *ppdata, 32,
8017 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
8018 reply_doserror(req, ERRSRV, ERRerror);
8021 /****************************************************************************
8022 Reply to a SMBfindclose (stop trans2 directory search).
8023 ****************************************************************************/
8025 void reply_findclose(struct smb_request *req)
8028 struct smbd_server_connection *sconn = smbd_server_conn;
8030 START_PROFILE(SMBfindclose);
8033 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8034 END_PROFILE(SMBfindclose);
8038 dptr_num = SVALS(req->vwv+0, 0);
8040 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num));
8042 dptr_close(sconn, &dptr_num);
8044 reply_outbuf(req, 0, 0);
8046 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num));
8048 END_PROFILE(SMBfindclose);
8052 /****************************************************************************
8053 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
8054 ****************************************************************************/
8056 void reply_findnclose(struct smb_request *req)
8060 START_PROFILE(SMBfindnclose);
8063 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8064 END_PROFILE(SMBfindnclose);
8068 dptr_num = SVAL(req->vwv+0, 0);
8070 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num));
8072 /* We never give out valid handles for a
8073 findnotifyfirst - so any dptr_num is ok here.
8076 reply_outbuf(req, 0, 0);
8078 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num));
8080 END_PROFILE(SMBfindnclose);
8084 static void handle_trans2(connection_struct *conn, struct smb_request *req,
8085 struct trans_state *state)
8087 if (Protocol >= PROTOCOL_NT1) {
8088 req->flags2 |= 0x40; /* IS_LONG_NAME */
8089 SSVAL(req->inbuf,smb_flg2,req->flags2);
8092 if (conn->encrypt_level == Required && !req->encrypted) {
8093 if (state->call != TRANSACT2_QFSINFO &&
8094 state->call != TRANSACT2_SETFSINFO) {
8095 DEBUG(0,("handle_trans2: encryption required "
8097 (unsigned int)state->call));
8098 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
8103 SMB_PERFCOUNT_SET_SUBOP(&req->pcd, state->call);
8105 /* Now we must call the relevant TRANS2 function */
8106 switch(state->call) {
8107 case TRANSACT2_OPEN:
8109 START_PROFILE(Trans2_open);
8110 call_trans2open(conn, req,
8111 &state->param, state->total_param,
8112 &state->data, state->total_data,
8113 state->max_data_return);
8114 END_PROFILE(Trans2_open);
8118 case TRANSACT2_FINDFIRST:
8120 START_PROFILE(Trans2_findfirst);
8121 call_trans2findfirst(conn, req,
8122 &state->param, state->total_param,
8123 &state->data, state->total_data,
8124 state->max_data_return);
8125 END_PROFILE(Trans2_findfirst);
8129 case TRANSACT2_FINDNEXT:
8131 START_PROFILE(Trans2_findnext);
8132 call_trans2findnext(conn, req,
8133 &state->param, state->total_param,
8134 &state->data, state->total_data,
8135 state->max_data_return);
8136 END_PROFILE(Trans2_findnext);
8140 case TRANSACT2_QFSINFO:
8142 START_PROFILE(Trans2_qfsinfo);
8143 call_trans2qfsinfo(conn, req,
8144 &state->param, state->total_param,
8145 &state->data, state->total_data,
8146 state->max_data_return);
8147 END_PROFILE(Trans2_qfsinfo);
8151 case TRANSACT2_SETFSINFO:
8153 START_PROFILE(Trans2_setfsinfo);
8154 call_trans2setfsinfo(conn, req,
8155 &state->param, state->total_param,
8156 &state->data, state->total_data,
8157 state->max_data_return);
8158 END_PROFILE(Trans2_setfsinfo);
8162 case TRANSACT2_QPATHINFO:
8163 case TRANSACT2_QFILEINFO:
8165 START_PROFILE(Trans2_qpathinfo);
8166 call_trans2qfilepathinfo(conn, req, state->call,
8167 &state->param, state->total_param,
8168 &state->data, state->total_data,
8169 state->max_data_return);
8170 END_PROFILE(Trans2_qpathinfo);
8174 case TRANSACT2_SETPATHINFO:
8175 case TRANSACT2_SETFILEINFO:
8177 START_PROFILE(Trans2_setpathinfo);
8178 call_trans2setfilepathinfo(conn, req, state->call,
8179 &state->param, state->total_param,
8180 &state->data, state->total_data,
8181 state->max_data_return);
8182 END_PROFILE(Trans2_setpathinfo);
8186 case TRANSACT2_FINDNOTIFYFIRST:
8188 START_PROFILE(Trans2_findnotifyfirst);
8189 call_trans2findnotifyfirst(conn, req,
8190 &state->param, state->total_param,
8191 &state->data, state->total_data,
8192 state->max_data_return);
8193 END_PROFILE(Trans2_findnotifyfirst);
8197 case TRANSACT2_FINDNOTIFYNEXT:
8199 START_PROFILE(Trans2_findnotifynext);
8200 call_trans2findnotifynext(conn, req,
8201 &state->param, state->total_param,
8202 &state->data, state->total_data,
8203 state->max_data_return);
8204 END_PROFILE(Trans2_findnotifynext);
8208 case TRANSACT2_MKDIR:
8210 START_PROFILE(Trans2_mkdir);
8211 call_trans2mkdir(conn, req,
8212 &state->param, state->total_param,
8213 &state->data, state->total_data,
8214 state->max_data_return);
8215 END_PROFILE(Trans2_mkdir);
8219 case TRANSACT2_GET_DFS_REFERRAL:
8221 START_PROFILE(Trans2_get_dfs_referral);
8222 call_trans2getdfsreferral(conn, req,
8223 &state->param, state->total_param,
8224 &state->data, state->total_data,
8225 state->max_data_return);
8226 END_PROFILE(Trans2_get_dfs_referral);
8230 case TRANSACT2_IOCTL:
8232 START_PROFILE(Trans2_ioctl);
8233 call_trans2ioctl(conn, req,
8234 &state->param, state->total_param,
8235 &state->data, state->total_data,
8236 state->max_data_return);
8237 END_PROFILE(Trans2_ioctl);
8242 /* Error in request */
8243 DEBUG(2,("Unknown request %d in trans2 call\n", state->call));
8244 reply_doserror(req, ERRSRV,ERRerror);
8248 /****************************************************************************
8249 Reply to a SMBtrans2.
8250 ****************************************************************************/
8252 void reply_trans2(struct smb_request *req)
8254 connection_struct *conn = req->conn;
8259 unsigned int tran_call;
8260 struct trans_state *state;
8263 START_PROFILE(SMBtrans2);
8265 if (req->wct < 14) {
8266 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8267 END_PROFILE(SMBtrans2);
8271 dsoff = SVAL(req->vwv+12, 0);
8272 dscnt = SVAL(req->vwv+11, 0);
8273 psoff = SVAL(req->vwv+10, 0);
8274 pscnt = SVAL(req->vwv+9, 0);
8275 tran_call = SVAL(req->vwv+14, 0);
8277 result = allow_new_trans(conn->pending_trans, req->mid);
8278 if (!NT_STATUS_IS_OK(result)) {
8279 DEBUG(2, ("Got invalid trans2 request: %s\n",
8280 nt_errstr(result)));
8281 reply_nterror(req, result);
8282 END_PROFILE(SMBtrans2);
8287 switch (tran_call) {
8288 /* List the allowed trans2 calls on IPC$ */
8289 case TRANSACT2_OPEN:
8290 case TRANSACT2_GET_DFS_REFERRAL:
8291 case TRANSACT2_QFILEINFO:
8292 case TRANSACT2_QFSINFO:
8293 case TRANSACT2_SETFSINFO:
8296 reply_doserror(req, ERRSRV, ERRaccess);
8297 END_PROFILE(SMBtrans2);
8302 if ((state = TALLOC_P(conn, struct trans_state)) == NULL) {
8303 DEBUG(0, ("talloc failed\n"));
8304 reply_nterror(req, NT_STATUS_NO_MEMORY);
8305 END_PROFILE(SMBtrans2);
8309 state->cmd = SMBtrans2;
8311 state->mid = req->mid;
8312 state->vuid = req->vuid;
8313 state->setup_count = SVAL(req->vwv+13, 0);
8314 state->setup = NULL;
8315 state->total_param = SVAL(req->vwv+0, 0);
8316 state->param = NULL;
8317 state->total_data = SVAL(req->vwv+1, 0);
8319 state->max_param_return = SVAL(req->vwv+2, 0);
8320 state->max_data_return = SVAL(req->vwv+3, 0);
8321 state->max_setup_return = SVAL(req->vwv+4, 0);
8322 state->close_on_completion = BITSETW(req->vwv+5, 0);
8323 state->one_way = BITSETW(req->vwv+5, 1);
8325 state->call = tran_call;
8327 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
8328 is so as a sanity check */
8329 if (state->setup_count != 1) {
8331 * Need to have rc=0 for ioctl to get job id for OS/2.
8332 * Network printing will fail if function is not successful.
8333 * Similar function in reply.c will be used if protocol
8334 * is LANMAN1.0 instead of LM1.2X002.
8335 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
8336 * outbuf doesn't have to be set(only job id is used).
8338 if ( (state->setup_count == 4)
8339 && (tran_call == TRANSACT2_IOCTL)
8340 && (SVAL(req->vwv+16, 0) == LMCAT_SPL)
8341 && (SVAL(req->vwv+17, 0) == LMFUNC_GETJOBID)) {
8342 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
8344 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state->setup_count));
8345 DEBUG(2,("Transaction is %d\n",tran_call));
8347 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8348 END_PROFILE(SMBtrans2);
8353 if ((dscnt > state->total_data) || (pscnt > state->total_param))
8356 if (state->total_data) {
8358 if (trans_oob(state->total_data, 0, dscnt)
8359 || trans_oob(smb_len(req->inbuf), dsoff, dscnt)) {
8363 /* Can't use talloc here, the core routines do realloc on the
8364 * params and data. */
8365 state->data = (char *)SMB_MALLOC(state->total_data);
8366 if (state->data == NULL) {
8367 DEBUG(0,("reply_trans2: data malloc fail for %u "
8368 "bytes !\n", (unsigned int)state->total_data));
8370 reply_nterror(req, NT_STATUS_NO_MEMORY);
8371 END_PROFILE(SMBtrans2);
8375 memcpy(state->data,smb_base(req->inbuf)+dsoff,dscnt);
8378 if (state->total_param) {
8380 if (trans_oob(state->total_param, 0, pscnt)
8381 || trans_oob(smb_len(req->inbuf), psoff, pscnt)) {
8385 /* Can't use talloc here, the core routines do realloc on the
8386 * params and data. */
8387 state->param = (char *)SMB_MALLOC(state->total_param);
8388 if (state->param == NULL) {
8389 DEBUG(0,("reply_trans: param malloc fail for %u "
8390 "bytes !\n", (unsigned int)state->total_param));
8391 SAFE_FREE(state->data);
8393 reply_nterror(req, NT_STATUS_NO_MEMORY);
8394 END_PROFILE(SMBtrans2);
8398 memcpy(state->param,smb_base(req->inbuf)+psoff,pscnt);
8401 state->received_data = dscnt;
8402 state->received_param = pscnt;
8404 if ((state->received_param == state->total_param) &&
8405 (state->received_data == state->total_data)) {
8407 handle_trans2(conn, req, state);
8409 SAFE_FREE(state->data);
8410 SAFE_FREE(state->param);
8412 END_PROFILE(SMBtrans2);
8416 DLIST_ADD(conn->pending_trans, state);
8418 /* We need to send an interim response then receive the rest
8419 of the parameter/data bytes */
8420 reply_outbuf(req, 0, 0);
8421 show_msg((char *)req->outbuf);
8422 END_PROFILE(SMBtrans2);
8427 DEBUG(0,("reply_trans2: invalid trans parameters\n"));
8428 SAFE_FREE(state->data);
8429 SAFE_FREE(state->param);
8431 END_PROFILE(SMBtrans2);
8432 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8436 /****************************************************************************
8437 Reply to a SMBtranss2
8438 ****************************************************************************/
8440 void reply_transs2(struct smb_request *req)
8442 connection_struct *conn = req->conn;
8443 unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
8444 struct trans_state *state;
8446 START_PROFILE(SMBtranss2);
8448 show_msg((char *)req->inbuf);
8451 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8452 END_PROFILE(SMBtranss2);
8456 for (state = conn->pending_trans; state != NULL;
8457 state = state->next) {
8458 if (state->mid == req->mid) {
8463 if ((state == NULL) || (state->cmd != SMBtrans2)) {
8464 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8465 END_PROFILE(SMBtranss2);
8469 /* Revise state->total_param and state->total_data in case they have
8470 changed downwards */
8472 if (SVAL(req->vwv+0, 0) < state->total_param)
8473 state->total_param = SVAL(req->vwv+0, 0);
8474 if (SVAL(req->vwv+1, 0) < state->total_data)
8475 state->total_data = SVAL(req->vwv+1, 0);
8477 pcnt = SVAL(req->vwv+2, 0);
8478 poff = SVAL(req->vwv+3, 0);
8479 pdisp = SVAL(req->vwv+4, 0);
8481 dcnt = SVAL(req->vwv+5, 0);
8482 doff = SVAL(req->vwv+6, 0);
8483 ddisp = SVAL(req->vwv+7, 0);
8485 state->received_param += pcnt;
8486 state->received_data += dcnt;
8488 if ((state->received_data > state->total_data) ||
8489 (state->received_param > state->total_param))
8493 if (trans_oob(state->total_param, pdisp, pcnt)
8494 || trans_oob(smb_len(req->inbuf), poff, pcnt)) {
8497 memcpy(state->param+pdisp,smb_base(req->inbuf)+poff,pcnt);
8501 if (trans_oob(state->total_data, ddisp, dcnt)
8502 || trans_oob(smb_len(req->inbuf), doff, dcnt)) {
8505 memcpy(state->data+ddisp, smb_base(req->inbuf)+doff,dcnt);
8508 if ((state->received_param < state->total_param) ||
8509 (state->received_data < state->total_data)) {
8510 END_PROFILE(SMBtranss2);
8514 handle_trans2(conn, req, state);
8516 DLIST_REMOVE(conn->pending_trans, state);
8517 SAFE_FREE(state->data);
8518 SAFE_FREE(state->param);
8521 END_PROFILE(SMBtranss2);
8526 DEBUG(0,("reply_transs2: invalid trans parameters\n"));
8527 DLIST_REMOVE(conn->pending_trans, state);
8528 SAFE_FREE(state->data);
8529 SAFE_FREE(state->param);
8531 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
8532 END_PROFILE(SMBtranss2);