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/>.
29 extern enum protocol_types Protocol
;
30 extern uint32 global_client_caps
;
31 extern struct current_user current_user
;
33 #define get_file_size(sbuf) ((sbuf).st_size)
34 #define DIR_ENTRY_SAFETY_MARGIN 4096
36 static char *store_file_unix_basic(connection_struct
*conn
,
39 const SMB_STRUCT_STAT
*psbuf
);
41 static char *store_file_unix_basic_info2(connection_struct
*conn
,
44 const SMB_STRUCT_STAT
*psbuf
);
46 /********************************************************************
47 Roundup a value to the nearest allocation roundup size boundary.
48 Only do this for Windows clients.
49 ********************************************************************/
51 SMB_BIG_UINT
smb_roundup(connection_struct
*conn
, SMB_BIG_UINT val
)
53 SMB_BIG_UINT rval
= lp_allocation_roundup_size(SNUM(conn
));
55 /* Only roundup for Windows clients. */
56 enum remote_arch_types ra_type
= get_remote_arch();
57 if (rval
&& (ra_type
!= RA_SAMBA
) && (ra_type
!= RA_CIFSFS
)) {
58 val
= SMB_ROUNDUP(val
,rval
);
63 /********************************************************************
64 Given a stat buffer return the allocated size on disk, taking into
66 ********************************************************************/
68 SMB_BIG_UINT
get_allocation_size(connection_struct
*conn
, files_struct
*fsp
, const SMB_STRUCT_STAT
*sbuf
)
72 if(S_ISDIR(sbuf
->st_mode
)) {
76 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
77 ret
= (SMB_BIG_UINT
)STAT_ST_BLOCKSIZE
* (SMB_BIG_UINT
)sbuf
->st_blocks
;
79 ret
= (SMB_BIG_UINT
)get_file_size(*sbuf
);
82 if (fsp
&& fsp
->initial_allocation_size
)
83 ret
= MAX(ret
,fsp
->initial_allocation_size
);
85 return smb_roundup(conn
, ret
);
88 /****************************************************************************
89 Utility functions for dealing with extended attributes.
90 ****************************************************************************/
92 /****************************************************************************
93 Refuse to allow clients to overwrite our private xattrs.
94 ****************************************************************************/
96 static bool samba_private_attr_name(const char *unix_ea_name
)
98 static const char *prohibited_ea_names
[] = {
99 SAMBA_POSIX_INHERITANCE_EA_NAME
,
100 SAMBA_XATTR_DOS_ATTRIB
,
106 for (i
= 0; prohibited_ea_names
[i
]; i
++) {
107 if (strequal( prohibited_ea_names
[i
], unix_ea_name
))
110 if (StrnCaseCmp(unix_ea_name
, SAMBA_XATTR_DOSSTREAM_PREFIX
,
111 strlen(SAMBA_XATTR_DOSSTREAM_PREFIX
)) == 0) {
117 /****************************************************************************
118 Get one EA value. Fill in a struct ea_struct.
119 ****************************************************************************/
121 NTSTATUS
get_ea_value(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
,
122 files_struct
*fsp
, const char *fname
,
123 const char *ea_name
, struct ea_struct
*pea
)
125 /* Get the value of this xattr. Max size is 64k. */
126 size_t attr_size
= 256;
132 val
= TALLOC_REALLOC_ARRAY(mem_ctx
, val
, char, attr_size
);
134 return NT_STATUS_NO_MEMORY
;
137 if (fsp
&& fsp
->fh
->fd
!= -1) {
138 sizeret
= SMB_VFS_FGETXATTR(fsp
, ea_name
, val
, attr_size
);
140 sizeret
= SMB_VFS_GETXATTR(conn
, fname
, ea_name
, val
, attr_size
);
143 if (sizeret
== -1 && errno
== ERANGE
&& attr_size
!= 65536) {
149 return map_nt_error_from_unix(errno
);
152 DEBUG(10,("get_ea_value: EA %s is of length %u\n", ea_name
, (unsigned int)sizeret
));
153 dump_data(10, (uint8
*)val
, sizeret
);
156 if (strnequal(ea_name
, "user.", 5)) {
157 pea
->name
= talloc_strdup(mem_ctx
, &ea_name
[5]);
159 pea
->name
= talloc_strdup(mem_ctx
, ea_name
);
161 if (pea
->name
== NULL
) {
163 return NT_STATUS_NO_MEMORY
;
165 pea
->value
.data
= (unsigned char *)val
;
166 pea
->value
.length
= (size_t)sizeret
;
170 NTSTATUS
get_ea_names_from_file(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
,
171 files_struct
*fsp
, const char *fname
,
172 char ***pnames
, size_t *pnum_names
)
174 /* Get a list of all xattrs. Max namesize is 64k. */
175 size_t ea_namelist_size
= 1024;
176 char *ea_namelist
= NULL
;
183 if (!lp_ea_support(SNUM(conn
))) {
190 * TALLOC the result early to get the talloc hierarchy right.
193 names
= TALLOC_ARRAY(mem_ctx
, char *, 1);
195 DEBUG(0, ("talloc failed\n"));
196 return NT_STATUS_NO_MEMORY
;
199 while (ea_namelist_size
<= 65536) {
201 ea_namelist
= TALLOC_REALLOC_ARRAY(
202 names
, ea_namelist
, char, ea_namelist_size
);
203 if (ea_namelist
== NULL
) {
204 DEBUG(0, ("talloc failed\n"));
206 return NT_STATUS_NO_MEMORY
;
209 if (fsp
&& fsp
->fh
->fd
!= -1) {
210 sizeret
= SMB_VFS_FLISTXATTR(fsp
, ea_namelist
,
213 sizeret
= SMB_VFS_LISTXATTR(conn
, fname
, ea_namelist
,
217 if ((sizeret
== -1) && (errno
== ERANGE
)) {
218 ea_namelist_size
*= 2;
227 return map_nt_error_from_unix(errno
);
230 DEBUG(10, ("get_ea_list_from_file: ea_namelist size = %u\n",
231 (unsigned int)sizeret
));
241 * Ensure the result is 0-terminated
244 if (ea_namelist
[sizeret
-1] != '\0') {
246 return NT_STATUS_INTERNAL_ERROR
;
254 for (p
= ea_namelist
; p
- ea_namelist
< sizeret
; p
+= strlen(p
)+1) {
258 tmp
= TALLOC_REALLOC_ARRAY(mem_ctx
, names
, char *, num_names
);
260 DEBUG(0, ("talloc failed\n"));
262 return NT_STATUS_NO_MEMORY
;
268 for (p
= ea_namelist
; p
- ea_namelist
< sizeret
; p
+= strlen(p
)+1) {
269 names
[num_names
++] = p
;
273 *pnum_names
= num_names
;
277 /****************************************************************************
278 Return a linked list of the total EA's. Plus the total size
279 ****************************************************************************/
281 static struct ea_list
*get_ea_list_from_file(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
, files_struct
*fsp
,
282 const char *fname
, size_t *pea_total_len
)
284 /* Get a list of all xattrs. Max namesize is 64k. */
287 struct ea_list
*ea_list_head
= NULL
;
292 if (!lp_ea_support(SNUM(conn
))) {
296 status
= get_ea_names_from_file(talloc_tos(), conn
, fsp
, fname
,
299 if (!NT_STATUS_IS_OK(status
) || (num_names
== 0)) {
303 for (i
=0; i
<num_names
; i
++) {
304 struct ea_list
*listp
;
307 if (strnequal(names
[i
], "system.", 7)
308 || samba_private_attr_name(names
[i
]))
311 listp
= TALLOC_P(mem_ctx
, struct ea_list
);
316 if (!NT_STATUS_IS_OK(get_ea_value(mem_ctx
, conn
, fsp
,
322 push_ascii_fstring(dos_ea_name
, listp
->ea
.name
);
325 4 + strlen(dos_ea_name
) + 1 + listp
->ea
.value
.length
;
327 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len "
328 "= %u\n", (unsigned int)*pea_total_len
, dos_ea_name
,
329 (unsigned int)listp
->ea
.value
.length
));
331 DLIST_ADD_END(ea_list_head
, listp
, struct ea_list
*);
335 /* Add on 4 for total length. */
336 if (*pea_total_len
) {
340 DEBUG(10, ("get_ea_list_from_file: total_len = %u\n",
341 (unsigned int)*pea_total_len
));
346 /****************************************************************************
347 Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
349 ****************************************************************************/
351 static unsigned int fill_ea_buffer(TALLOC_CTX
*mem_ctx
, char *pdata
, unsigned int total_data_size
,
352 connection_struct
*conn
, struct ea_list
*ea_list
)
354 unsigned int ret_data_size
= 4;
357 SMB_ASSERT(total_data_size
>= 4);
359 if (!lp_ea_support(SNUM(conn
))) {
364 for (p
= pdata
+ 4; ea_list
; ea_list
= ea_list
->next
) {
367 push_ascii_fstring(dos_ea_name
, ea_list
->ea
.name
);
368 dos_namelen
= strlen(dos_ea_name
);
369 if (dos_namelen
> 255 || dos_namelen
== 0) {
372 if (ea_list
->ea
.value
.length
> 65535) {
375 if (4 + dos_namelen
+ 1 + ea_list
->ea
.value
.length
> total_data_size
) {
379 /* We know we have room. */
380 SCVAL(p
,0,ea_list
->ea
.flags
);
381 SCVAL(p
,1,dos_namelen
);
382 SSVAL(p
,2,ea_list
->ea
.value
.length
);
383 fstrcpy(p
+4, dos_ea_name
);
384 memcpy( p
+ 4 + dos_namelen
+ 1, ea_list
->ea
.value
.data
, ea_list
->ea
.value
.length
);
386 total_data_size
-= 4 + dos_namelen
+ 1 + ea_list
->ea
.value
.length
;
387 p
+= 4 + dos_namelen
+ 1 + ea_list
->ea
.value
.length
;
390 ret_data_size
= PTR_DIFF(p
, pdata
);
391 DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size
));
392 SIVAL(pdata
,0,ret_data_size
);
393 return ret_data_size
;
396 static unsigned int estimate_ea_size(connection_struct
*conn
, files_struct
*fsp
, const char *fname
)
398 size_t total_ea_len
= 0;
399 TALLOC_CTX
*mem_ctx
= NULL
;
401 if (!lp_ea_support(SNUM(conn
))) {
404 mem_ctx
= talloc_tos();
405 (void)get_ea_list_from_file(mem_ctx
, conn
, fsp
, fname
, &total_ea_len
);
409 /****************************************************************************
410 Ensure the EA name is case insensitive by matching any existing EA name.
411 ****************************************************************************/
413 static void canonicalize_ea_name(connection_struct
*conn
, files_struct
*fsp
, const char *fname
, fstring unix_ea_name
)
416 TALLOC_CTX
*mem_ctx
= talloc_tos();
417 struct ea_list
*ea_list
= get_ea_list_from_file(mem_ctx
, conn
, fsp
, fname
, &total_ea_len
);
419 for (; ea_list
; ea_list
= ea_list
->next
) {
420 if (strequal(&unix_ea_name
[5], ea_list
->ea
.name
)) {
421 DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
422 &unix_ea_name
[5], ea_list
->ea
.name
));
423 safe_strcpy(&unix_ea_name
[5], ea_list
->ea
.name
, sizeof(fstring
)-6);
429 /****************************************************************************
430 Set or delete an extended attribute.
431 ****************************************************************************/
433 NTSTATUS
set_ea(connection_struct
*conn
, files_struct
*fsp
, const char *fname
, struct ea_list
*ea_list
)
435 if (!lp_ea_support(SNUM(conn
))) {
436 return NT_STATUS_EAS_NOT_SUPPORTED
;
439 for (;ea_list
; ea_list
= ea_list
->next
) {
441 fstring unix_ea_name
;
443 fstrcpy(unix_ea_name
, "user."); /* All EA's must start with user. */
444 fstrcat(unix_ea_name
, ea_list
->ea
.name
);
446 canonicalize_ea_name(conn
, fsp
, fname
, unix_ea_name
);
448 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name
, (unsigned int)ea_list
->ea
.value
.length
));
450 if (samba_private_attr_name(unix_ea_name
)) {
451 DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name
));
452 return NT_STATUS_ACCESS_DENIED
;
455 if (ea_list
->ea
.value
.length
== 0) {
456 /* Remove the attribute. */
457 if (fsp
&& (fsp
->fh
->fd
!= -1)) {
458 DEBUG(10,("set_ea: deleting ea name %s on file %s by file descriptor.\n",
459 unix_ea_name
, fsp
->fsp_name
));
460 ret
= SMB_VFS_FREMOVEXATTR(fsp
, unix_ea_name
);
462 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
463 unix_ea_name
, fname
));
464 ret
= SMB_VFS_REMOVEXATTR(conn
, fname
, unix_ea_name
);
467 /* Removing a non existent attribute always succeeds. */
468 if (ret
== -1 && errno
== ENOATTR
) {
469 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
475 if (fsp
&& (fsp
->fh
->fd
!= -1)) {
476 DEBUG(10,("set_ea: setting ea name %s on file %s by file descriptor.\n",
477 unix_ea_name
, fsp
->fsp_name
));
478 ret
= SMB_VFS_FSETXATTR(fsp
, unix_ea_name
,
479 ea_list
->ea
.value
.data
, ea_list
->ea
.value
.length
, 0);
481 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
482 unix_ea_name
, fname
));
483 ret
= SMB_VFS_SETXATTR(conn
, fname
, unix_ea_name
,
484 ea_list
->ea
.value
.data
, ea_list
->ea
.value
.length
, 0);
490 if (errno
== ENOTSUP
) {
491 return NT_STATUS_EAS_NOT_SUPPORTED
;
494 return map_nt_error_from_unix(errno
);
500 /****************************************************************************
501 Read a list of EA names from an incoming data buffer. Create an ea_list with them.
502 ****************************************************************************/
504 static struct ea_list
*read_ea_name_list(TALLOC_CTX
*ctx
, const char *pdata
, size_t data_size
)
506 struct ea_list
*ea_list_head
= NULL
;
509 while (offset
+ 2 < data_size
) {
510 struct ea_list
*eal
= TALLOC_ZERO_P(ctx
, struct ea_list
);
511 unsigned int namelen
= CVAL(pdata
,offset
);
513 offset
++; /* Go past the namelen byte. */
515 /* integer wrap paranioa. */
516 if ((offset
+ namelen
< offset
) || (offset
+ namelen
< namelen
) ||
517 (offset
> data_size
) || (namelen
> data_size
) ||
518 (offset
+ namelen
>= data_size
)) {
521 /* Ensure the name is null terminated. */
522 if (pdata
[offset
+ namelen
] != '\0') {
525 pull_ascii_talloc(ctx
, &eal
->ea
.name
, &pdata
[offset
]);
530 offset
+= (namelen
+ 1); /* Go past the name + terminating zero. */
531 DLIST_ADD_END(ea_list_head
, eal
, struct ea_list
*);
532 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal
->ea
.name
));
538 /****************************************************************************
539 Read one EA list entry from the buffer.
540 ****************************************************************************/
542 struct ea_list
*read_ea_list_entry(TALLOC_CTX
*ctx
, const char *pdata
, size_t data_size
, size_t *pbytes_used
)
544 struct ea_list
*eal
= TALLOC_ZERO_P(ctx
, struct ea_list
);
546 unsigned int namelen
;
556 eal
->ea
.flags
= CVAL(pdata
,0);
557 namelen
= CVAL(pdata
,1);
558 val_len
= SVAL(pdata
,2);
560 if (4 + namelen
+ 1 + val_len
> data_size
) {
564 /* Ensure the name is null terminated. */
565 if (pdata
[namelen
+ 4] != '\0') {
568 pull_ascii_talloc(ctx
, &eal
->ea
.name
, pdata
+ 4);
573 eal
->ea
.value
= data_blob_talloc(eal
, NULL
, (size_t)val_len
+ 1);
574 if (!eal
->ea
.value
.data
) {
578 memcpy(eal
->ea
.value
.data
, pdata
+ 4 + namelen
+ 1, val_len
);
580 /* Ensure we're null terminated just in case we print the value. */
581 eal
->ea
.value
.data
[val_len
] = '\0';
582 /* But don't count the null. */
583 eal
->ea
.value
.length
--;
586 *pbytes_used
= 4 + namelen
+ 1 + val_len
;
589 DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal
->ea
.name
));
590 dump_data(10, eal
->ea
.value
.data
, eal
->ea
.value
.length
);
595 /****************************************************************************
596 Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
597 ****************************************************************************/
599 static struct ea_list
*read_ea_list(TALLOC_CTX
*ctx
, const char *pdata
, size_t data_size
)
601 struct ea_list
*ea_list_head
= NULL
;
603 size_t bytes_used
= 0;
605 while (offset
< data_size
) {
606 struct ea_list
*eal
= read_ea_list_entry(ctx
, pdata
+ offset
, data_size
- offset
, &bytes_used
);
612 DLIST_ADD_END(ea_list_head
, eal
, struct ea_list
*);
613 offset
+= bytes_used
;
619 /****************************************************************************
620 Count the total EA size needed.
621 ****************************************************************************/
623 static size_t ea_list_size(struct ea_list
*ealist
)
626 struct ea_list
*listp
;
629 for (listp
= ealist
; listp
; listp
= listp
->next
) {
630 push_ascii_fstring(dos_ea_name
, listp
->ea
.name
);
631 ret
+= 4 + strlen(dos_ea_name
) + 1 + listp
->ea
.value
.length
;
633 /* Add on 4 for total length. */
641 /****************************************************************************
642 Return a union of EA's from a file list and a list of names.
643 The TALLOC context for the two lists *MUST* be identical as we steal
644 memory from one list to add to another. JRA.
645 ****************************************************************************/
647 static struct ea_list
*ea_list_union(struct ea_list
*name_list
, struct ea_list
*file_list
, size_t *total_ea_len
)
649 struct ea_list
*nlistp
, *flistp
;
651 for (nlistp
= name_list
; nlistp
; nlistp
= nlistp
->next
) {
652 for (flistp
= file_list
; flistp
; flistp
= flistp
->next
) {
653 if (strequal(nlistp
->ea
.name
, flistp
->ea
.name
)) {
659 /* Copy the data from this entry. */
660 nlistp
->ea
.flags
= flistp
->ea
.flags
;
661 nlistp
->ea
.value
= flistp
->ea
.value
;
664 nlistp
->ea
.flags
= 0;
665 ZERO_STRUCT(nlistp
->ea
.value
);
669 *total_ea_len
= ea_list_size(name_list
);
673 /****************************************************************************
674 Send the required number of replies back.
675 We assume all fields other than the data fields are
676 set correctly for the type of call.
677 HACK ! Always assumes smb_setup field is zero.
678 ****************************************************************************/
680 void send_trans2_replies(connection_struct
*conn
,
681 struct smb_request
*req
,
688 /* As we are using a protocol > LANMAN1 then the max_send
689 variable must have been set in the sessetupX call.
690 This takes precedence over the max_xmit field in the
691 global struct. These different max_xmit variables should
692 be merged as this is now too confusing */
694 int data_to_send
= datasize
;
695 int params_to_send
= paramsize
;
697 const char *pp
= params
;
698 const char *pd
= pdata
;
699 int params_sent_thistime
, data_sent_thistime
, total_sent_thistime
;
700 int alignment_offset
= 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
701 int data_alignment_offset
= 0;
702 bool overflow
= False
;
704 /* Modify the data_to_send and datasize and set the error if
705 we're trying to send more than max_data_bytes. We still send
706 the part of the packet(s) that fit. Strange, but needed
709 if (max_data_bytes
> 0 && datasize
> max_data_bytes
) {
710 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
711 max_data_bytes
, datasize
));
712 datasize
= data_to_send
= max_data_bytes
;
716 /* If there genuinely are no parameters or data to send just send the empty packet */
718 if(params_to_send
== 0 && data_to_send
== 0) {
719 reply_outbuf(req
, 10, 0);
720 show_msg((char *)req
->outbuf
);
724 /* When sending params and data ensure that both are nicely aligned */
725 /* Only do this alignment when there is also data to send - else
726 can cause NT redirector problems. */
728 if (((params_to_send
% 4) != 0) && (data_to_send
!= 0))
729 data_alignment_offset
= 4 - (params_to_send
% 4);
731 /* Space is bufsize minus Netbios over TCP header minus SMB header */
732 /* The alignment_offset is to align the param bytes on an even byte
733 boundary. NT 4.0 Beta needs this to work correctly. */
735 useable_space
= max_send
- (smb_size
738 + data_alignment_offset
);
740 if (useable_space
< 0) {
741 DEBUG(0, ("send_trans2_replies failed sanity useable_space "
742 "= %d!!!", useable_space
));
743 exit_server_cleanly("send_trans2_replies: Not enough space");
746 while (params_to_send
|| data_to_send
) {
747 /* Calculate whether we will totally or partially fill this packet */
749 total_sent_thistime
= params_to_send
+ data_to_send
;
751 /* We can never send more than useable_space */
753 * Note that 'useable_space' does not include the alignment offsets,
754 * but we must include the alignment offsets in the calculation of
755 * the length of the data we send over the wire, as the alignment offsets
756 * are sent here. Fix from Marc_Jacobsen@hp.com.
759 total_sent_thistime
= MIN(total_sent_thistime
, useable_space
);
761 reply_outbuf(req
, 10, total_sent_thistime
+ alignment_offset
762 + data_alignment_offset
);
764 /* Set total params and data to be sent */
765 SSVAL(req
->outbuf
,smb_tprcnt
,paramsize
);
766 SSVAL(req
->outbuf
,smb_tdrcnt
,datasize
);
768 /* Calculate how many parameters and data we can fit into
769 * this packet. Parameters get precedence
772 params_sent_thistime
= MIN(params_to_send
,useable_space
);
773 data_sent_thistime
= useable_space
- params_sent_thistime
;
774 data_sent_thistime
= MIN(data_sent_thistime
,data_to_send
);
776 SSVAL(req
->outbuf
,smb_prcnt
, params_sent_thistime
);
778 /* smb_proff is the offset from the start of the SMB header to the
779 parameter bytes, however the first 4 bytes of outbuf are
780 the Netbios over TCP header. Thus use smb_base() to subtract
781 them from the calculation */
783 SSVAL(req
->outbuf
,smb_proff
,
784 ((smb_buf(req
->outbuf
)+alignment_offset
)
785 - smb_base(req
->outbuf
)));
787 if(params_sent_thistime
== 0)
788 SSVAL(req
->outbuf
,smb_prdisp
,0);
790 /* Absolute displacement of param bytes sent in this packet */
791 SSVAL(req
->outbuf
,smb_prdisp
,pp
- params
);
793 SSVAL(req
->outbuf
,smb_drcnt
, data_sent_thistime
);
794 if(data_sent_thistime
== 0) {
795 SSVAL(req
->outbuf
,smb_droff
,0);
796 SSVAL(req
->outbuf
,smb_drdisp
, 0);
798 /* The offset of the data bytes is the offset of the
799 parameter bytes plus the number of parameters being sent this time */
800 SSVAL(req
->outbuf
, smb_droff
,
801 ((smb_buf(req
->outbuf
)+alignment_offset
)
802 - smb_base(req
->outbuf
))
803 + params_sent_thistime
+ data_alignment_offset
);
804 SSVAL(req
->outbuf
,smb_drdisp
, pd
- pdata
);
807 /* Initialize the padding for alignment */
809 if (alignment_offset
!= 0) {
810 memset(smb_buf(req
->outbuf
), 0, alignment_offset
);
813 /* Copy the param bytes into the packet */
815 if(params_sent_thistime
) {
816 memcpy((smb_buf(req
->outbuf
)+alignment_offset
), pp
,
817 params_sent_thistime
);
820 /* Copy in the data bytes */
821 if(data_sent_thistime
) {
822 if (data_alignment_offset
!= 0) {
823 memset((smb_buf(req
->outbuf
)+alignment_offset
+
824 params_sent_thistime
), 0,
825 data_alignment_offset
);
827 memcpy(smb_buf(req
->outbuf
)+alignment_offset
828 +params_sent_thistime
+data_alignment_offset
,
829 pd
,data_sent_thistime
);
832 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
833 params_sent_thistime
, data_sent_thistime
, useable_space
));
834 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
835 params_to_send
, data_to_send
, paramsize
, datasize
));
838 error_packet_set((char *)req
->outbuf
,
839 ERRDOS
,ERRbufferoverflow
,
840 STATUS_BUFFER_OVERFLOW
,
844 /* Send the packet */
845 show_msg((char *)req
->outbuf
);
846 if (!srv_send_smb(smbd_server_fd(),
848 IS_CONN_ENCRYPTED(conn
)))
849 exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
851 TALLOC_FREE(req
->outbuf
);
853 pp
+= params_sent_thistime
;
854 pd
+= data_sent_thistime
;
856 params_to_send
-= params_sent_thistime
;
857 data_to_send
-= data_sent_thistime
;
860 if(params_to_send
< 0 || data_to_send
< 0) {
861 DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
862 params_to_send
, data_to_send
));
870 /****************************************************************************
871 Reply to a TRANSACT2_OPEN.
872 ****************************************************************************/
874 static void call_trans2open(connection_struct
*conn
,
875 struct smb_request
*req
,
876 char **pparams
, int total_params
,
877 char **ppdata
, int total_data
,
878 unsigned int max_data_bytes
)
880 char *params
= *pparams
;
881 char *pdata
= *ppdata
;
886 bool return_additional_info
;
897 SMB_STRUCT_STAT sbuf
;
900 struct ea_list
*ea_list
= NULL
;
905 uint32 create_disposition
;
906 uint32 create_options
= 0;
907 TALLOC_CTX
*ctx
= talloc_tos();
910 * Ensure we have enough parameters to perform the operation.
913 if (total_params
< 29) {
914 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
918 flags
= SVAL(params
, 0);
919 deny_mode
= SVAL(params
, 2);
920 open_attr
= SVAL(params
,6);
921 oplock_request
= (flags
& REQUEST_OPLOCK
) ? EXCLUSIVE_OPLOCK
: 0;
922 if (oplock_request
) {
923 oplock_request
|= (flags
& REQUEST_BATCH_OPLOCK
) ? BATCH_OPLOCK
: 0;
927 return_additional_info
= BITSETW(params
,0);
928 open_sattr
= SVAL(params
, 4);
929 open_time
= make_unix_date3(params
+8);
931 open_ofun
= SVAL(params
,12);
932 open_size
= IVAL(params
,14);
936 reply_doserror(req
, ERRSRV
, ERRaccess
);
940 srvstr_get_path(ctx
, params
, req
->flags2
, &fname
, pname
,
941 total_params
- 28, STR_TERMINATE
,
943 if (!NT_STATUS_IS_OK(status
)) {
944 reply_nterror(req
, status
);
948 DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
949 fname
, (unsigned int)deny_mode
, (unsigned int)open_attr
,
950 (unsigned int)open_ofun
, open_size
));
952 if (open_ofun
== 0) {
953 reply_nterror(req
, NT_STATUS_OBJECT_NAME_COLLISION
);
957 if (!map_open_params_to_ntcreate(fname
, deny_mode
, open_ofun
,
962 reply_doserror(req
, ERRDOS
, ERRbadaccess
);
966 /* Any data in this call is an EA list. */
967 if (total_data
&& (total_data
!= 4) && !lp_ea_support(SNUM(conn
))) {
968 reply_nterror(req
, NT_STATUS_EAS_NOT_SUPPORTED
);
972 if (total_data
!= 4) {
973 if (total_data
< 10) {
974 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
978 if (IVAL(pdata
,0) > total_data
) {
979 DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
980 IVAL(pdata
,0), (unsigned int)total_data
));
981 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
985 ea_list
= read_ea_list(talloc_tos(), pdata
+ 4,
988 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
991 } else if (IVAL(pdata
,0) != 4) {
992 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
996 status
= create_file(conn
, /* conn */
998 0, /* root_dir_fid */
1000 access_mask
, /* access_mask */
1001 share_mode
, /* share_access */
1002 create_disposition
, /* create_disposition*/
1003 create_options
, /* create_options */
1004 open_attr
, /* file_attributes */
1005 oplock_request
, /* oplock_request */
1006 open_size
, /* allocation_size */
1008 ea_list
, /* ea_list */
1010 &smb_action
, /* pinfo */
1013 if (!NT_STATUS_IS_OK(status
)) {
1014 if (open_was_deferred(req
->mid
)) {
1015 /* We have re-scheduled this call. */
1018 reply_openerror(req
, status
);
1022 size
= get_file_size(sbuf
);
1023 fattr
= dos_mode(conn
,fsp
->fsp_name
,&sbuf
);
1024 mtime
= sbuf
.st_mtime
;
1025 inode
= sbuf
.st_ino
;
1027 close_file(fsp
,ERROR_CLOSE
);
1028 reply_doserror(req
, ERRDOS
,ERRnoaccess
);
1032 /* Realloc the size of parameters and data we will return */
1033 *pparams
= (char *)SMB_REALLOC(*pparams
, 30);
1034 if(*pparams
== NULL
) {
1035 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
1040 SSVAL(params
,0,fsp
->fnum
);
1041 SSVAL(params
,2,fattr
);
1042 srv_put_dos_date2(params
,4, mtime
);
1043 SIVAL(params
,8, (uint32
)size
);
1044 SSVAL(params
,12,deny_mode
);
1045 SSVAL(params
,14,0); /* open_type - file or directory. */
1046 SSVAL(params
,16,0); /* open_state - only valid for IPC device. */
1048 if (oplock_request
&& lp_fake_oplocks(SNUM(conn
))) {
1049 smb_action
|= EXTENDED_OPLOCK_GRANTED
;
1052 SSVAL(params
,18,smb_action
);
1055 * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
1057 SIVAL(params
,20,inode
);
1058 SSVAL(params
,24,0); /* Padding. */
1060 uint32 ea_size
= estimate_ea_size(conn
, fsp
, fsp
->fsp_name
);
1061 SIVAL(params
, 26, ea_size
);
1063 SIVAL(params
, 26, 0);
1066 /* Send the required number of replies */
1067 send_trans2_replies(conn
, req
, params
, 30, *ppdata
, 0, max_data_bytes
);
1070 /*********************************************************
1071 Routine to check if a given string matches exactly.
1072 as a special case a mask of "." does NOT match. That
1073 is required for correct wildcard semantics
1074 Case can be significant or not.
1075 **********************************************************/
1077 static bool exact_match(connection_struct
*conn
,
1081 if (mask
[0] == '.' && mask
[1] == 0)
1083 if (dptr_has_wild(conn
->dirptr
)) {
1086 if (conn
->case_sensitive
)
1087 return strcmp(str
,mask
)==0;
1089 return StrCaseCmp(str
,mask
) == 0;
1092 /****************************************************************************
1093 Return the filetype for UNIX extensions.
1094 ****************************************************************************/
1096 static uint32
unix_filetype(mode_t mode
)
1099 return UNIX_TYPE_FILE
;
1100 else if(S_ISDIR(mode
))
1101 return UNIX_TYPE_DIR
;
1103 else if(S_ISLNK(mode
))
1104 return UNIX_TYPE_SYMLINK
;
1107 else if(S_ISCHR(mode
))
1108 return UNIX_TYPE_CHARDEV
;
1111 else if(S_ISBLK(mode
))
1112 return UNIX_TYPE_BLKDEV
;
1115 else if(S_ISFIFO(mode
))
1116 return UNIX_TYPE_FIFO
;
1119 else if(S_ISSOCK(mode
))
1120 return UNIX_TYPE_SOCKET
;
1123 DEBUG(0,("unix_filetype: unknown filetype %u\n", (unsigned)mode
));
1124 return UNIX_TYPE_UNKNOWN
;
1127 /****************************************************************************
1128 Map wire perms onto standard UNIX permissions. Obey share restrictions.
1129 ****************************************************************************/
1131 enum perm_type
{ PERM_NEW_FILE
, PERM_NEW_DIR
, PERM_EXISTING_FILE
, PERM_EXISTING_DIR
};
1133 static NTSTATUS
unix_perms_from_wire( connection_struct
*conn
,
1134 SMB_STRUCT_STAT
*psbuf
,
1136 enum perm_type ptype
,
1141 if (perms
== SMB_MODE_NO_CHANGE
) {
1142 if (!VALID_STAT(*psbuf
)) {
1143 return NT_STATUS_INVALID_PARAMETER
;
1145 *ret_perms
= psbuf
->st_mode
;
1146 return NT_STATUS_OK
;
1150 ret
|= ((perms
& UNIX_X_OTH
) ? S_IXOTH
: 0);
1151 ret
|= ((perms
& UNIX_W_OTH
) ? S_IWOTH
: 0);
1152 ret
|= ((perms
& UNIX_R_OTH
) ? S_IROTH
: 0);
1153 ret
|= ((perms
& UNIX_X_GRP
) ? S_IXGRP
: 0);
1154 ret
|= ((perms
& UNIX_W_GRP
) ? S_IWGRP
: 0);
1155 ret
|= ((perms
& UNIX_R_GRP
) ? S_IRGRP
: 0);
1156 ret
|= ((perms
& UNIX_X_USR
) ? S_IXUSR
: 0);
1157 ret
|= ((perms
& UNIX_W_USR
) ? S_IWUSR
: 0);
1158 ret
|= ((perms
& UNIX_R_USR
) ? S_IRUSR
: 0);
1160 ret
|= ((perms
& UNIX_STICKY
) ? S_ISVTX
: 0);
1163 ret
|= ((perms
& UNIX_SET_GID
) ? S_ISGID
: 0);
1166 ret
|= ((perms
& UNIX_SET_UID
) ? S_ISUID
: 0);
1171 /* Apply mode mask */
1172 ret
&= lp_create_mask(SNUM(conn
));
1173 /* Add in force bits */
1174 ret
|= lp_force_create_mode(SNUM(conn
));
1177 ret
&= lp_dir_mask(SNUM(conn
));
1178 /* Add in force bits */
1179 ret
|= lp_force_dir_mode(SNUM(conn
));
1181 case PERM_EXISTING_FILE
:
1182 /* Apply mode mask */
1183 ret
&= lp_security_mask(SNUM(conn
));
1184 /* Add in force bits */
1185 ret
|= lp_force_security_mode(SNUM(conn
));
1187 case PERM_EXISTING_DIR
:
1188 /* Apply mode mask */
1189 ret
&= lp_dir_security_mask(SNUM(conn
));
1190 /* Add in force bits */
1191 ret
|= lp_force_dir_security_mode(SNUM(conn
));
1196 return NT_STATUS_OK
;
1199 /****************************************************************************
1200 Needed to show the msdfs symlinks as directories. Modifies psbuf
1201 to be a directory if it's a msdfs link.
1202 ****************************************************************************/
1204 static bool check_msdfs_link(connection_struct
*conn
,
1205 const char *pathname
,
1206 SMB_STRUCT_STAT
*psbuf
)
1208 int saved_errno
= errno
;
1209 if(lp_host_msdfs() &&
1210 lp_msdfs_root(SNUM(conn
)) &&
1211 is_msdfs_link(conn
, pathname
, psbuf
)) {
1213 DEBUG(5,("check_msdfs_link: Masquerading msdfs link %s "
1216 psbuf
->st_mode
= (psbuf
->st_mode
& 0xFFF) | S_IFDIR
;
1217 errno
= saved_errno
;
1220 errno
= saved_errno
;
1225 /****************************************************************************
1226 Get a level dependent lanman2 dir entry.
1227 ****************************************************************************/
1229 static bool get_lanman2_dir_entry(TALLOC_CTX
*ctx
,
1230 connection_struct
*conn
,
1232 const char *path_mask
,
1235 int requires_resume_key
,
1241 int space_remaining
,
1243 bool *got_exact_match
,
1244 int *last_entry_off
,
1245 struct ea_list
*name_list
)
1249 SMB_STRUCT_STAT sbuf
;
1250 const char *mask
= NULL
;
1251 char *pathreal
= NULL
;
1252 const char *fname
= NULL
;
1253 char *p
, *q
, *pdata
= *ppdata
;
1257 SMB_OFF_T file_size
= 0;
1258 SMB_BIG_UINT allocation_size
= 0;
1260 struct timespec mdate_ts
, adate_ts
, create_date_ts
;
1261 time_t mdate
= (time_t)0, adate
= (time_t)0, create_date
= (time_t)0;
1263 char *last_entry_ptr
;
1265 uint32 nt_extmode
; /* Used for NT connections instead of mode */
1266 bool needslash
= ( conn
->dirpath
[strlen(conn
->dirpath
) -1] != '/');
1267 bool check_mangled_names
= lp_manglednames(conn
->params
);
1268 char mangled_name
[13]; /* mangled 8.3 name. */
1270 *out_of_space
= False
;
1271 *got_exact_match
= False
;
1273 ZERO_STRUCT(mdate_ts
);
1274 ZERO_STRUCT(adate_ts
);
1275 ZERO_STRUCT(create_date_ts
);
1277 if (!conn
->dirptr
) {
1281 p
= strrchr_m(path_mask
,'/');
1284 mask
= talloc_strdup(ctx
,"*.*");
1294 bool ms_dfs_link
= False
;
1296 /* Needed if we run out of space */
1297 long curr_dirpos
= prev_dirpos
= dptr_TellDir(conn
->dirptr
);
1298 dname
= dptr_ReadDirName(ctx
,conn
->dirptr
,&curr_dirpos
,&sbuf
);
1301 * Due to bugs in NT client redirectors we are not using
1302 * resume keys any more - set them to zero.
1303 * Check out the related comments in findfirst/findnext.
1309 DEBUG(8,("get_lanman2_dir_entry:readdir on dirptr 0x%lx now at offset %ld\n",
1310 (long)conn
->dirptr
,curr_dirpos
));
1317 * fname may get mangled, dname is never mangled.
1318 * Whenever we're accessing the filesystem we use
1319 * pathreal which is composed from dname.
1325 /* Mangle fname if it's an illegal name. */
1326 if (mangle_must_mangle(dname
,conn
->params
)) {
1327 if (!name_to_8_3(dname
,mangled_name
,True
,conn
->params
)) {
1328 continue; /* Error - couldn't mangle. */
1330 fname
= mangled_name
;
1333 if(!(got_match
= *got_exact_match
= exact_match(conn
, fname
, mask
))) {
1334 got_match
= mask_match(fname
, mask
, conn
->case_sensitive
);
1337 if(!got_match
&& check_mangled_names
&&
1338 !mangle_is_8_3(fname
, False
, conn
->params
)) {
1340 * It turns out that NT matches wildcards against
1341 * both long *and* short names. This may explain some
1342 * of the wildcard wierdness from old DOS clients
1343 * that some people have been seeing.... JRA.
1345 /* Force the mangling into 8.3. */
1346 if (!name_to_8_3( fname
, mangled_name
, False
, conn
->params
)) {
1347 continue; /* Error - couldn't mangle. */
1350 if(!(got_match
= *got_exact_match
= exact_match(conn
, mangled_name
, mask
))) {
1351 got_match
= mask_match(mangled_name
, mask
, conn
->case_sensitive
);
1356 bool isdots
= (ISDOT(dname
) || ISDOTDOT(dname
));
1358 if (dont_descend
&& !isdots
) {
1364 pathreal
= talloc_asprintf(ctx
,
1369 pathreal
= talloc_asprintf(ctx
,
1379 if (INFO_LEVEL_IS_UNIX(info_level
)) {
1380 if (SMB_VFS_LSTAT(conn
,pathreal
,&sbuf
) != 0) {
1381 DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
1382 pathreal
,strerror(errno
)));
1383 TALLOC_FREE(pathreal
);
1386 } else if (!VALID_STAT(sbuf
) && SMB_VFS_STAT(conn
,pathreal
,&sbuf
) != 0) {
1387 /* Needed to show the msdfs symlinks as
1390 ms_dfs_link
= check_msdfs_link(conn
, pathreal
, &sbuf
);
1392 DEBUG(5,("get_lanman2_dir_entry:Couldn't stat [%s] (%s)\n",
1393 pathreal
,strerror(errno
)));
1394 TALLOC_FREE(pathreal
);
1400 mode
= dos_mode_msdfs(conn
,pathreal
,&sbuf
);
1402 mode
= dos_mode(conn
,pathreal
,&sbuf
);
1405 if (!dir_check_ftype(conn
,mode
,dirtype
)) {
1406 DEBUG(5,("get_lanman2_dir_entry: [%s] attribs didn't match %x\n",fname
,dirtype
));
1407 TALLOC_FREE(pathreal
);
1411 if (!(mode
& aDIR
)) {
1412 file_size
= get_file_size(sbuf
);
1414 allocation_size
= get_allocation_size(conn
,NULL
,&sbuf
);
1416 mdate_ts
= get_mtimespec(&sbuf
);
1417 adate_ts
= get_atimespec(&sbuf
);
1418 create_date_ts
= get_create_timespec(&sbuf
,lp_fake_dir_create_times(SNUM(conn
)));
1420 if (ask_sharemode
) {
1421 struct timespec write_time_ts
;
1422 struct file_id fileid
;
1424 fileid
= vfs_file_id_from_sbuf(conn
, &sbuf
);
1425 get_file_infos(fileid
, NULL
, &write_time_ts
);
1426 if (!null_timespec(write_time_ts
)) {
1427 mdate_ts
= write_time_ts
;
1431 if (lp_dos_filetime_resolution(SNUM(conn
))) {
1432 dos_filetime_timespec(&create_date_ts
);
1433 dos_filetime_timespec(&mdate_ts
);
1434 dos_filetime_timespec(&adate_ts
);
1437 create_date
= convert_timespec_to_time_t(create_date_ts
);
1438 mdate
= convert_timespec_to_time_t(mdate_ts
);
1439 adate
= convert_timespec_to_time_t(adate_ts
);
1441 DEBUG(5,("get_lanman2_dir_entry: found %s fname=%s\n",pathreal
,fname
));
1445 dptr_DirCacheAdd(conn
->dirptr
, dname
, curr_dirpos
);
1452 nt_extmode
= mode
? mode
: FILE_ATTRIBUTE_NORMAL
;
1454 switch (info_level
) {
1455 case SMB_FIND_INFO_STANDARD
:
1456 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1457 if(requires_resume_key
) {
1461 srv_put_dos_date2(p
,0,create_date
);
1462 srv_put_dos_date2(p
,4,adate
);
1463 srv_put_dos_date2(p
,8,mdate
);
1464 SIVAL(p
,12,(uint32
)file_size
);
1465 SIVAL(p
,16,(uint32
)allocation_size
);
1469 if (flags2
& FLAGS2_UNICODE_STRINGS
) {
1470 p
+= ucs2_align(base_data
, p
, 0);
1472 len
= srvstr_push(base_data
, flags2
, p
,
1473 fname
, PTR_DIFF(end_data
, p
),
1475 if (flags2
& FLAGS2_UNICODE_STRINGS
) {
1477 SCVAL(nameptr
, -1, len
- 2);
1479 SCVAL(nameptr
, -1, 0);
1483 SCVAL(nameptr
, -1, len
- 1);
1485 SCVAL(nameptr
, -1, 0);
1491 case SMB_FIND_EA_SIZE
:
1492 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_SIZE\n"));
1493 if(requires_resume_key
) {
1497 srv_put_dos_date2(p
,0,create_date
);
1498 srv_put_dos_date2(p
,4,adate
);
1499 srv_put_dos_date2(p
,8,mdate
);
1500 SIVAL(p
,12,(uint32
)file_size
);
1501 SIVAL(p
,16,(uint32
)allocation_size
);
1504 unsigned int ea_size
= estimate_ea_size(conn
, NULL
, pathreal
);
1505 SIVAL(p
,22,ea_size
); /* Extended attributes */
1509 len
= srvstr_push(base_data
, flags2
,
1510 p
, fname
, PTR_DIFF(end_data
, p
),
1511 STR_TERMINATE
| STR_NOALIGN
);
1512 if (flags2
& FLAGS2_UNICODE_STRINGS
) {
1525 SCVAL(nameptr
,0,len
);
1527 SCVAL(p
,0,0); p
+= 1; /* Extra zero byte ? - why.. */
1530 case SMB_FIND_EA_LIST
:
1532 struct ea_list
*file_list
= NULL
;
1535 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_EA_LIST\n"));
1539 if(requires_resume_key
) {
1543 srv_put_dos_date2(p
,0,create_date
);
1544 srv_put_dos_date2(p
,4,adate
);
1545 srv_put_dos_date2(p
,8,mdate
);
1546 SIVAL(p
,12,(uint32
)file_size
);
1547 SIVAL(p
,16,(uint32
)allocation_size
);
1549 p
+= 22; /* p now points to the EA area. */
1551 file_list
= get_ea_list_from_file(ctx
, conn
, NULL
, pathreal
, &ea_len
);
1552 name_list
= ea_list_union(name_list
, file_list
, &ea_len
);
1554 /* We need to determine if this entry will fit in the space available. */
1555 /* Max string size is 255 bytes. */
1556 if (PTR_DIFF(p
+ 255 + ea_len
,pdata
) > space_remaining
) {
1557 /* Move the dirptr back to prev_dirpos */
1558 dptr_SeekDir(conn
->dirptr
, prev_dirpos
);
1559 *out_of_space
= True
;
1560 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1561 return False
; /* Not finished - just out of space */
1564 /* Push the ea_data followed by the name. */
1565 p
+= fill_ea_buffer(ctx
, p
, space_remaining
, conn
, name_list
);
1567 len
= srvstr_push(base_data
, flags2
,
1568 p
+ 1, fname
, PTR_DIFF(end_data
, p
+1),
1569 STR_TERMINATE
| STR_NOALIGN
);
1570 if (flags2
& FLAGS2_UNICODE_STRINGS
) {
1583 SCVAL(nameptr
,0,len
);
1585 SCVAL(p
,0,0); p
+= 1; /* Extra zero byte ? - why.. */
1589 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
1590 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1591 was_8_3
= mangle_is_8_3(fname
, True
, conn
->params
);
1593 SIVAL(p
,0,reskey
); p
+= 4;
1594 put_long_date_timespec(p
,create_date_ts
); p
+= 8;
1595 put_long_date_timespec(p
,adate_ts
); p
+= 8;
1596 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1597 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1598 SOFF_T(p
,0,file_size
); p
+= 8;
1599 SOFF_T(p
,0,allocation_size
); p
+= 8;
1600 SIVAL(p
,0,nt_extmode
); p
+= 4;
1601 q
= p
; p
+= 4; /* q is placeholder for name length. */
1603 unsigned int ea_size
= estimate_ea_size(conn
, NULL
, pathreal
);
1604 SIVAL(p
,0,ea_size
); /* Extended attributes */
1607 /* Clear the short name buffer. This is
1608 * IMPORTANT as not doing so will trigger
1609 * a Win2k client bug. JRA.
1611 if (!was_8_3
&& check_mangled_names
) {
1612 if (!name_to_8_3(fname
,mangled_name
,True
,
1614 /* Error - mangle failed ! */
1615 memset(mangled_name
,'\0',12);
1617 mangled_name
[12] = 0;
1618 len
= srvstr_push(base_data
, flags2
,
1619 p
+2, mangled_name
, 24,
1620 STR_UPPER
|STR_UNICODE
);
1622 memset(p
+ 2 + len
,'\0',24 - len
);
1629 len
= srvstr_push(base_data
, flags2
, p
,
1630 fname
, PTR_DIFF(end_data
, p
),
1631 STR_TERMINATE_ASCII
);
1634 SIVAL(p
,0,0); /* Ensure any padding is null. */
1635 len
= PTR_DIFF(p
, pdata
);
1636 len
= (len
+ 3) & ~3;
1641 case SMB_FIND_FILE_DIRECTORY_INFO
:
1642 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1644 SIVAL(p
,0,reskey
); p
+= 4;
1645 put_long_date_timespec(p
,create_date_ts
); p
+= 8;
1646 put_long_date_timespec(p
,adate_ts
); p
+= 8;
1647 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1648 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1649 SOFF_T(p
,0,file_size
); p
+= 8;
1650 SOFF_T(p
,0,allocation_size
); p
+= 8;
1651 SIVAL(p
,0,nt_extmode
); p
+= 4;
1652 len
= srvstr_push(base_data
, flags2
,
1653 p
+ 4, fname
, PTR_DIFF(end_data
, p
+4),
1654 STR_TERMINATE_ASCII
);
1657 SIVAL(p
,0,0); /* Ensure any padding is null. */
1658 len
= PTR_DIFF(p
, pdata
);
1659 len
= (len
+ 3) & ~3;
1664 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
1665 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1667 SIVAL(p
,0,reskey
); p
+= 4;
1668 put_long_date_timespec(p
,create_date_ts
); p
+= 8;
1669 put_long_date_timespec(p
,adate_ts
); p
+= 8;
1670 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1671 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1672 SOFF_T(p
,0,file_size
); p
+= 8;
1673 SOFF_T(p
,0,allocation_size
); p
+= 8;
1674 SIVAL(p
,0,nt_extmode
); p
+= 4;
1675 q
= p
; p
+= 4; /* q is placeholder for name length. */
1677 unsigned int ea_size
= estimate_ea_size(conn
, NULL
, pathreal
);
1678 SIVAL(p
,0,ea_size
); /* Extended attributes */
1681 len
= srvstr_push(base_data
, flags2
, p
,
1682 fname
, PTR_DIFF(end_data
, p
),
1683 STR_TERMINATE_ASCII
);
1687 SIVAL(p
,0,0); /* Ensure any padding is null. */
1688 len
= PTR_DIFF(p
, pdata
);
1689 len
= (len
+ 3) & ~3;
1694 case SMB_FIND_FILE_NAMES_INFO
:
1695 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1697 SIVAL(p
,0,reskey
); p
+= 4;
1699 /* this must *not* be null terminated or w2k gets in a loop trying to set an
1700 acl on a dir (tridge) */
1701 len
= srvstr_push(base_data
, flags2
, p
,
1702 fname
, PTR_DIFF(end_data
, p
),
1703 STR_TERMINATE_ASCII
);
1706 SIVAL(p
,0,0); /* Ensure any padding is null. */
1707 len
= PTR_DIFF(p
, pdata
);
1708 len
= (len
+ 3) & ~3;
1713 case SMB_FIND_ID_FULL_DIRECTORY_INFO
:
1714 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1716 SIVAL(p
,0,reskey
); p
+= 4;
1717 put_long_date_timespec(p
,create_date_ts
); p
+= 8;
1718 put_long_date_timespec(p
,adate_ts
); p
+= 8;
1719 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1720 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1721 SOFF_T(p
,0,file_size
); p
+= 8;
1722 SOFF_T(p
,0,allocation_size
); p
+= 8;
1723 SIVAL(p
,0,nt_extmode
); p
+= 4;
1724 q
= p
; p
+= 4; /* q is placeholder for name length. */
1726 unsigned int ea_size
= estimate_ea_size(conn
, NULL
, pathreal
);
1727 SIVAL(p
,0,ea_size
); /* Extended attributes */
1730 SIVAL(p
,0,0); p
+= 4; /* Unknown - reserved ? */
1731 SIVAL(p
,0,sbuf
.st_ino
); p
+= 4; /* FileIndexLow */
1732 SIVAL(p
,0,sbuf
.st_dev
); p
+= 4; /* FileIndexHigh */
1733 len
= srvstr_push(base_data
, flags2
, p
,
1734 fname
, PTR_DIFF(end_data
, p
),
1735 STR_TERMINATE_ASCII
);
1738 SIVAL(p
,0,0); /* Ensure any padding is null. */
1739 len
= PTR_DIFF(p
, pdata
);
1740 len
= (len
+ 3) & ~3;
1745 case SMB_FIND_ID_BOTH_DIRECTORY_INFO
:
1746 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1747 was_8_3
= mangle_is_8_3(fname
, True
, conn
->params
);
1749 SIVAL(p
,0,reskey
); p
+= 4;
1750 put_long_date_timespec(p
,create_date_ts
); p
+= 8;
1751 put_long_date_timespec(p
,adate_ts
); p
+= 8;
1752 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1753 put_long_date_timespec(p
,mdate_ts
); p
+= 8;
1754 SOFF_T(p
,0,file_size
); p
+= 8;
1755 SOFF_T(p
,0,allocation_size
); p
+= 8;
1756 SIVAL(p
,0,nt_extmode
); p
+= 4;
1757 q
= p
; p
+= 4; /* q is placeholder for name length */
1759 unsigned int ea_size
= estimate_ea_size(conn
, NULL
, pathreal
);
1760 SIVAL(p
,0,ea_size
); /* Extended attributes */
1763 /* Clear the short name buffer. This is
1764 * IMPORTANT as not doing so will trigger
1765 * a Win2k client bug. JRA.
1767 if (!was_8_3
&& check_mangled_names
) {
1768 if (!name_to_8_3(fname
,mangled_name
,True
,
1770 /* Error - mangle failed ! */
1771 memset(mangled_name
,'\0',12);
1773 mangled_name
[12] = 0;
1774 len
= srvstr_push(base_data
, flags2
,
1775 p
+2, mangled_name
, 24,
1776 STR_UPPER
|STR_UNICODE
);
1779 memset(p
+ 2 + len
,'\0',24 - len
);
1786 SSVAL(p
,0,0); p
+= 2; /* Reserved ? */
1787 SIVAL(p
,0,sbuf
.st_ino
); p
+= 4; /* FileIndexLow */
1788 SIVAL(p
,0,sbuf
.st_dev
); p
+= 4; /* FileIndexHigh */
1789 len
= srvstr_push(base_data
, flags2
, p
,
1790 fname
, PTR_DIFF(end_data
, p
),
1791 STR_TERMINATE_ASCII
);
1794 SIVAL(p
,0,0); /* Ensure any padding is null. */
1795 len
= PTR_DIFF(p
, pdata
);
1796 len
= (len
+ 3) & ~3;
1801 /* CIFS UNIX Extension. */
1803 case SMB_FIND_FILE_UNIX
:
1804 case SMB_FIND_FILE_UNIX_INFO2
:
1806 SIVAL(p
,0,reskey
); p
+= 4; /* Used for continuing search. */
1808 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1810 if (info_level
== SMB_FIND_FILE_UNIX
) {
1811 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX\n"));
1812 p
= store_file_unix_basic(conn
, p
,
1814 len
= srvstr_push(base_data
, flags2
, p
,
1815 fname
, PTR_DIFF(end_data
, p
),
1818 DEBUG(10,("get_lanman2_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
1819 p
= store_file_unix_basic_info2(conn
, p
,
1823 len
= srvstr_push(base_data
, flags2
, p
, fname
,
1824 PTR_DIFF(end_data
, p
), 0);
1825 SIVAL(nameptr
, 0, len
);
1829 SIVAL(p
,0,0); /* Ensure any padding is null. */
1831 len
= PTR_DIFF(p
, pdata
);
1832 len
= (len
+ 3) & ~3;
1833 SIVAL(pdata
,0,len
); /* Offset from this structure to the beginning of the next one */
1835 /* End of SMB_QUERY_FILE_UNIX_BASIC */
1844 if (PTR_DIFF(p
,pdata
) > space_remaining
) {
1845 /* Move the dirptr back to prev_dirpos */
1846 dptr_SeekDir(conn
->dirptr
, prev_dirpos
);
1847 *out_of_space
= True
;
1848 DEBUG(9,("get_lanman2_dir_entry: out of space\n"));
1849 return False
; /* Not finished - just out of space */
1852 /* Setup the last entry pointer, as an offset from base_data */
1853 *last_entry_off
= PTR_DIFF(last_entry_ptr
,base_data
);
1854 /* Advance the data pointer to the next slot */
1860 /****************************************************************************
1861 Reply to a TRANS2_FINDFIRST.
1862 ****************************************************************************/
1864 static void call_trans2findfirst(connection_struct
*conn
,
1865 struct smb_request
*req
,
1866 char **pparams
, int total_params
,
1867 char **ppdata
, int total_data
,
1868 unsigned int max_data_bytes
)
1870 /* We must be careful here that we don't return more than the
1871 allowed number of data bytes. If this means returning fewer than
1872 maxentries then so be it. We assume that the redirector has
1873 enough room for the fixed number of parameter bytes it has
1875 char *params
= *pparams
;
1876 char *pdata
= *ppdata
;
1880 uint16 findfirst_flags
;
1881 bool close_after_first
;
1883 bool requires_resume_key
;
1885 char *directory
= NULL
;
1888 int last_entry_off
=0;
1892 bool finished
= False
;
1893 bool dont_descend
= False
;
1894 bool out_of_space
= False
;
1895 int space_remaining
;
1896 bool mask_contains_wcard
= False
;
1897 SMB_STRUCT_STAT sbuf
;
1898 struct ea_list
*ea_list
= NULL
;
1899 NTSTATUS ntstatus
= NT_STATUS_OK
;
1900 bool ask_sharemode
= lp_parm_bool(SNUM(conn
), "smbd", "search ask sharemode", true);
1901 TALLOC_CTX
*ctx
= talloc_tos();
1903 if (total_params
< 13) {
1904 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
1908 dirtype
= SVAL(params
,0);
1909 maxentries
= SVAL(params
,2);
1910 findfirst_flags
= SVAL(params
,4);
1911 close_after_first
= (findfirst_flags
& FLAG_TRANS2_FIND_CLOSE
);
1912 close_if_end
= (findfirst_flags
& FLAG_TRANS2_FIND_CLOSE_IF_END
);
1913 requires_resume_key
= (findfirst_flags
& FLAG_TRANS2_FIND_REQUIRE_RESUME
);
1914 info_level
= SVAL(params
,6);
1916 DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
1917 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
1918 (unsigned int)dirtype
, maxentries
, close_after_first
, close_if_end
, requires_resume_key
,
1919 info_level
, max_data_bytes
));
1922 /* W2K3 seems to treat zero as 1. */
1926 switch (info_level
) {
1927 case SMB_FIND_INFO_STANDARD
:
1928 case SMB_FIND_EA_SIZE
:
1929 case SMB_FIND_EA_LIST
:
1930 case SMB_FIND_FILE_DIRECTORY_INFO
:
1931 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
1932 case SMB_FIND_FILE_NAMES_INFO
:
1933 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
1934 case SMB_FIND_ID_FULL_DIRECTORY_INFO
:
1935 case SMB_FIND_ID_BOTH_DIRECTORY_INFO
:
1937 case SMB_FIND_FILE_UNIX
:
1938 case SMB_FIND_FILE_UNIX_INFO2
:
1939 /* Always use filesystem for UNIX mtime query. */
1940 ask_sharemode
= false;
1941 if (!lp_unix_extensions()) {
1942 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
1947 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
1951 srvstr_get_path_wcard(ctx
, params
, req
->flags2
, &directory
,
1952 params
+12, total_params
- 12,
1953 STR_TERMINATE
, &ntstatus
, &mask_contains_wcard
);
1954 if (!NT_STATUS_IS_OK(ntstatus
)) {
1955 reply_nterror(req
, ntstatus
);
1959 ntstatus
= resolve_dfspath_wcard(ctx
, conn
,
1960 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
1963 &mask_contains_wcard
);
1964 if (!NT_STATUS_IS_OK(ntstatus
)) {
1965 if (NT_STATUS_EQUAL(ntstatus
,NT_STATUS_PATH_NOT_COVERED
)) {
1966 reply_botherror(req
, NT_STATUS_PATH_NOT_COVERED
,
1967 ERRSRV
, ERRbadpath
);
1970 reply_nterror(req
, ntstatus
);
1974 ntstatus
= unix_convert(ctx
, conn
, directory
, True
, &directory
, &mask
, &sbuf
);
1975 if (!NT_STATUS_IS_OK(ntstatus
)) {
1976 reply_nterror(req
, ntstatus
);
1980 ntstatus
= check_name(conn
, directory
);
1981 if (!NT_STATUS_IS_OK(ntstatus
)) {
1982 reply_nterror(req
, ntstatus
);
1986 p
= strrchr_m(directory
,'/');
1988 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
1989 if((directory
[0] == '.') && (directory
[1] == '\0')) {
1990 mask
= talloc_strdup(ctx
,"*");
1992 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
1995 mask_contains_wcard
= True
;
1997 directory
= talloc_strdup(talloc_tos(), "./");
1999 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2006 DEBUG(5,("dir=%s, mask = %s\n",directory
, mask
));
2008 if (info_level
== SMB_FIND_EA_LIST
) {
2011 if (total_data
< 4) {
2012 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2016 ea_size
= IVAL(pdata
,0);
2017 if (ea_size
!= total_data
) {
2018 DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
2019 total_data=%u (should be %u)\n", (unsigned int)total_data
, (unsigned int)IVAL(pdata
,0) ));
2020 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2024 if (!lp_ea_support(SNUM(conn
))) {
2025 reply_doserror(req
, ERRDOS
, ERReasnotsupported
);
2029 /* Pull out the list of names. */
2030 ea_list
= read_ea_name_list(ctx
, pdata
+ 4, ea_size
- 4);
2032 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2037 *ppdata
= (char *)SMB_REALLOC(
2038 *ppdata
, max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
);
2039 if(*ppdata
== NULL
) {
2040 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2044 data_end
= pdata
+ max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
- 1;
2046 /* Realloc the params space */
2047 *pparams
= (char *)SMB_REALLOC(*pparams
, 10);
2048 if (*pparams
== NULL
) {
2049 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2054 /* Save the wildcard match and attribs we are using on this directory -
2055 needed as lanman2 assumes these are being saved between calls */
2057 ntstatus
= dptr_create(conn
,
2063 mask_contains_wcard
,
2067 if (!NT_STATUS_IS_OK(ntstatus
)) {
2068 reply_nterror(req
, ntstatus
);
2072 dptr_num
= dptr_dnum(conn
->dirptr
);
2073 DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num
, mask
, dirtype
));
2075 /* We don't need to check for VOL here as this is returned by
2076 a different TRANS2 call. */
2078 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n", conn
->dirpath
,lp_dontdescend(SNUM(conn
))));
2079 if (in_list(conn
->dirpath
,lp_dontdescend(SNUM(conn
)),conn
->case_sensitive
))
2080 dont_descend
= True
;
2083 space_remaining
= max_data_bytes
;
2084 out_of_space
= False
;
2086 for (i
=0;(i
<maxentries
) && !finished
&& !out_of_space
;i
++) {
2087 bool got_exact_match
= False
;
2089 /* this is a heuristic to avoid seeking the dirptr except when
2090 absolutely necessary. It allows for a filename of about 40 chars */
2091 if (space_remaining
< DIRLEN_GUESS
&& numentries
> 0) {
2092 out_of_space
= True
;
2095 finished
= !get_lanman2_dir_entry(ctx
,
2098 mask
,dirtype
,info_level
,
2099 requires_resume_key
,dont_descend
,
2102 space_remaining
, &out_of_space
,
2104 &last_entry_off
, ea_list
);
2107 if (finished
&& out_of_space
)
2110 if (!finished
&& !out_of_space
)
2114 * As an optimisation if we know we aren't looking
2115 * for a wildcard name (ie. the name matches the wildcard exactly)
2116 * then we can finish on any (first) match.
2117 * This speeds up large directory searches. JRA.
2123 /* Ensure space_remaining never goes -ve. */
2124 if (PTR_DIFF(p
,pdata
) > max_data_bytes
) {
2125 space_remaining
= 0;
2126 out_of_space
= true;
2128 space_remaining
= max_data_bytes
- PTR_DIFF(p
,pdata
);
2132 /* Check if we can close the dirptr */
2133 if(close_after_first
|| (finished
&& close_if_end
)) {
2134 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num
));
2135 dptr_close(&dptr_num
);
2139 * If there are no matching entries we must return ERRDOS/ERRbadfile -
2140 * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2141 * the protocol level is less than NT1. Tested with smbclient. JRA.
2142 * This should fix the OS/2 client bug #2335.
2145 if(numentries
== 0) {
2146 dptr_close(&dptr_num
);
2147 if (Protocol
< PROTOCOL_NT1
) {
2148 reply_doserror(req
, ERRDOS
, ERRnofiles
);
2151 reply_botherror(req
, NT_STATUS_NO_SUCH_FILE
,
2152 ERRDOS
, ERRbadfile
);
2157 /* At this point pdata points to numentries directory entries. */
2159 /* Set up the return parameter block */
2160 SSVAL(params
,0,dptr_num
);
2161 SSVAL(params
,2,numentries
);
2162 SSVAL(params
,4,finished
);
2163 SSVAL(params
,6,0); /* Never an EA error */
2164 SSVAL(params
,8,last_entry_off
);
2166 send_trans2_replies(conn
, req
, params
, 10, pdata
, PTR_DIFF(p
,pdata
),
2169 if ((! *directory
) && dptr_path(dptr_num
)) {
2170 directory
= talloc_strdup(talloc_tos(),dptr_path(dptr_num
));
2172 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2176 DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2177 smb_fn_name(CVAL(req
->inbuf
,smb_com
)),
2178 mask
, directory
, dirtype
, numentries
) );
2181 * Force a name mangle here to ensure that the
2182 * mask as an 8.3 name is top of the mangled cache.
2183 * The reasons for this are subtle. Don't remove
2184 * this code unless you know what you are doing
2185 * (see PR#13758). JRA.
2188 if(!mangle_is_8_3_wildcards( mask
, False
, conn
->params
)) {
2189 char mangled_name
[13];
2190 name_to_8_3(mask
, mangled_name
, True
, conn
->params
);
2196 /****************************************************************************
2197 Reply to a TRANS2_FINDNEXT.
2198 ****************************************************************************/
2200 static void call_trans2findnext(connection_struct
*conn
,
2201 struct smb_request
*req
,
2202 char **pparams
, int total_params
,
2203 char **ppdata
, int total_data
,
2204 unsigned int max_data_bytes
)
2206 /* We must be careful here that we don't return more than the
2207 allowed number of data bytes. If this means returning fewer than
2208 maxentries then so be it. We assume that the redirector has
2209 enough room for the fixed number of parameter bytes it has
2211 char *params
= *pparams
;
2212 char *pdata
= *ppdata
;
2218 uint16 findnext_flags
;
2219 bool close_after_request
;
2221 bool requires_resume_key
;
2223 bool mask_contains_wcard
= False
;
2224 char *resume_name
= NULL
;
2225 const char *mask
= NULL
;
2226 const char *directory
= NULL
;
2230 int i
, last_entry_off
=0;
2231 bool finished
= False
;
2232 bool dont_descend
= False
;
2233 bool out_of_space
= False
;
2234 int space_remaining
;
2235 struct ea_list
*ea_list
= NULL
;
2236 NTSTATUS ntstatus
= NT_STATUS_OK
;
2237 bool ask_sharemode
= lp_parm_bool(SNUM(conn
), "smbd", "search ask sharemode", true);
2238 TALLOC_CTX
*ctx
= talloc_tos();
2240 if (total_params
< 13) {
2241 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2245 dptr_num
= SVAL(params
,0);
2246 maxentries
= SVAL(params
,2);
2247 info_level
= SVAL(params
,4);
2248 resume_key
= IVAL(params
,6);
2249 findnext_flags
= SVAL(params
,10);
2250 close_after_request
= (findnext_flags
& FLAG_TRANS2_FIND_CLOSE
);
2251 close_if_end
= (findnext_flags
& FLAG_TRANS2_FIND_CLOSE_IF_END
);
2252 requires_resume_key
= (findnext_flags
& FLAG_TRANS2_FIND_REQUIRE_RESUME
);
2253 continue_bit
= (findnext_flags
& FLAG_TRANS2_FIND_CONTINUE
);
2255 srvstr_get_path_wcard(ctx
, params
, req
->flags2
, &resume_name
,
2257 total_params
- 12, STR_TERMINATE
, &ntstatus
,
2258 &mask_contains_wcard
);
2259 if (!NT_STATUS_IS_OK(ntstatus
)) {
2260 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2261 complain (it thinks we're asking for the directory above the shared
2262 path or an invalid name). Catch this as the resume name is only compared, never used in
2263 a file access. JRA. */
2264 srvstr_pull_talloc(ctx
, params
, req
->flags2
,
2265 &resume_name
, params
+12,
2269 if (!resume_name
|| !(ISDOT(resume_name
) || ISDOTDOT(resume_name
))) {
2270 reply_nterror(req
, ntstatus
);
2275 DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2276 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2277 resume_key = %d resume name = %s continue=%d level = %d\n",
2278 dptr_num
, max_data_bytes
, maxentries
, close_after_request
, close_if_end
,
2279 requires_resume_key
, resume_key
, resume_name
, continue_bit
, info_level
));
2282 /* W2K3 seems to treat zero as 1. */
2286 switch (info_level
) {
2287 case SMB_FIND_INFO_STANDARD
:
2288 case SMB_FIND_EA_SIZE
:
2289 case SMB_FIND_EA_LIST
:
2290 case SMB_FIND_FILE_DIRECTORY_INFO
:
2291 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
2292 case SMB_FIND_FILE_NAMES_INFO
:
2293 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
2294 case SMB_FIND_ID_FULL_DIRECTORY_INFO
:
2295 case SMB_FIND_ID_BOTH_DIRECTORY_INFO
:
2297 case SMB_FIND_FILE_UNIX
:
2298 case SMB_FIND_FILE_UNIX_INFO2
:
2299 /* Always use filesystem for UNIX mtime query. */
2300 ask_sharemode
= false;
2301 if (!lp_unix_extensions()) {
2302 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2307 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2311 if (info_level
== SMB_FIND_EA_LIST
) {
2314 if (total_data
< 4) {
2315 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2319 ea_size
= IVAL(pdata
,0);
2320 if (ea_size
!= total_data
) {
2321 DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2322 total_data=%u (should be %u)\n", (unsigned int)total_data
, (unsigned int)IVAL(pdata
,0) ));
2323 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2327 if (!lp_ea_support(SNUM(conn
))) {
2328 reply_doserror(req
, ERRDOS
, ERReasnotsupported
);
2332 /* Pull out the list of names. */
2333 ea_list
= read_ea_name_list(ctx
, pdata
+ 4, ea_size
- 4);
2335 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2340 *ppdata
= (char *)SMB_REALLOC(
2341 *ppdata
, max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
);
2342 if(*ppdata
== NULL
) {
2343 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2348 data_end
= pdata
+ max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
- 1;
2350 /* Realloc the params space */
2351 *pparams
= (char *)SMB_REALLOC(*pparams
, 6*SIZEOFWORD
);
2352 if(*pparams
== NULL
) {
2353 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2359 /* Check that the dptr is valid */
2360 if(!(conn
->dirptr
= dptr_fetch_lanman2(dptr_num
))) {
2361 reply_doserror(req
, ERRDOS
, ERRnofiles
);
2365 string_set(&conn
->dirpath
,dptr_path(dptr_num
));
2367 /* Get the wildcard mask from the dptr */
2368 if((p
= dptr_wcard(dptr_num
))== NULL
) {
2369 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num
));
2370 reply_doserror(req
, ERRDOS
, ERRnofiles
);
2375 directory
= conn
->dirpath
;
2377 /* Get the attr mask from the dptr */
2378 dirtype
= dptr_attr(dptr_num
);
2380 DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2381 dptr_num
, mask
, dirtype
,
2383 dptr_TellDir(conn
->dirptr
)));
2385 /* We don't need to check for VOL here as this is returned by
2386 a different TRANS2 call. */
2388 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",conn
->dirpath
,lp_dontdescend(SNUM(conn
))));
2389 if (in_list(conn
->dirpath
,lp_dontdescend(SNUM(conn
)),conn
->case_sensitive
))
2390 dont_descend
= True
;
2393 space_remaining
= max_data_bytes
;
2394 out_of_space
= False
;
2397 * Seek to the correct position. We no longer use the resume key but
2398 * depend on the last file name instead.
2401 if(*resume_name
&& !continue_bit
) {
2404 long current_pos
= 0;
2406 * Remember, name_to_8_3 is called by
2407 * get_lanman2_dir_entry(), so the resume name
2408 * could be mangled. Ensure we check the unmangled name.
2411 if (mangle_is_mangled(resume_name
, conn
->params
)) {
2412 char *new_resume_name
= NULL
;
2413 mangle_lookup_name_from_8_3(ctx
,
2417 if (new_resume_name
) {
2418 resume_name
= new_resume_name
;
2423 * Fix for NT redirector problem triggered by resume key indexes
2424 * changing between directory scans. We now return a resume key of 0
2425 * and instead look for the filename to continue from (also given
2426 * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2427 * findfirst/findnext (as is usual) then the directory pointer
2428 * should already be at the correct place.
2431 finished
= !dptr_SearchDir(conn
->dirptr
, resume_name
, ¤t_pos
, &st
);
2432 } /* end if resume_name && !continue_bit */
2434 for (i
=0;(i
<(int)maxentries
) && !finished
&& !out_of_space
;i
++) {
2435 bool got_exact_match
= False
;
2437 /* this is a heuristic to avoid seeking the dirptr except when
2438 absolutely necessary. It allows for a filename of about 40 chars */
2439 if (space_remaining
< DIRLEN_GUESS
&& numentries
> 0) {
2440 out_of_space
= True
;
2443 finished
= !get_lanman2_dir_entry(ctx
,
2446 mask
,dirtype
,info_level
,
2447 requires_resume_key
,dont_descend
,
2450 space_remaining
, &out_of_space
,
2452 &last_entry_off
, ea_list
);
2455 if (finished
&& out_of_space
)
2458 if (!finished
&& !out_of_space
)
2462 * As an optimisation if we know we aren't looking
2463 * for a wildcard name (ie. the name matches the wildcard exactly)
2464 * then we can finish on any (first) match.
2465 * This speeds up large directory searches. JRA.
2471 space_remaining
= max_data_bytes
- PTR_DIFF(p
,pdata
);
2474 DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2475 smb_fn_name(CVAL(req
->inbuf
,smb_com
)),
2476 mask
, directory
, dirtype
, numentries
) );
2478 /* Check if we can close the dirptr */
2479 if(close_after_request
|| (finished
&& close_if_end
)) {
2480 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num
));
2481 dptr_close(&dptr_num
); /* This frees up the saved mask */
2484 /* Set up the return parameter block */
2485 SSVAL(params
,0,numentries
);
2486 SSVAL(params
,2,finished
);
2487 SSVAL(params
,4,0); /* Never an EA error */
2488 SSVAL(params
,6,last_entry_off
);
2490 send_trans2_replies(conn
, req
, params
, 8, pdata
, PTR_DIFF(p
,pdata
),
2496 unsigned char *create_volume_objectid(connection_struct
*conn
, unsigned char objid
[16])
2498 E_md4hash(lp_servicename(SNUM(conn
)),objid
);
2502 static void samba_extended_info_version(struct smb_extended_info
*extended_info
)
2504 SMB_ASSERT(extended_info
!= NULL
);
2506 extended_info
->samba_magic
= SAMBA_EXTENDED_INFO_MAGIC
;
2507 extended_info
->samba_version
= ((SAMBA_VERSION_MAJOR
& 0xff) << 24)
2508 | ((SAMBA_VERSION_MINOR
& 0xff) << 16)
2509 | ((SAMBA_VERSION_RELEASE
& 0xff) << 8);
2510 #ifdef SAMBA_VERSION_REVISION
2511 extended_info
->samba_version
|= (tolower(*SAMBA_VERSION_REVISION
) - 'a' + 1) & 0xff;
2513 extended_info
->samba_subversion
= 0;
2514 #ifdef SAMBA_VERSION_RC_RELEASE
2515 extended_info
->samba_subversion
|= (SAMBA_VERSION_RC_RELEASE
& 0xff) << 24;
2517 #ifdef SAMBA_VERSION_PRE_RELEASE
2518 extended_info
->samba_subversion
|= (SAMBA_VERSION_PRE_RELEASE
& 0xff) << 16;
2521 #ifdef SAMBA_VERSION_VENDOR_PATCH
2522 extended_info
->samba_subversion
|= (SAMBA_VERSION_VENDOR_PATCH
& 0xffff);
2524 extended_info
->samba_gitcommitdate
= 0;
2525 #ifdef SAMBA_VERSION_GIT_COMMIT_TIME
2526 unix_to_nt_time(&extended_info
->samba_gitcommitdate
, SAMBA_VERSION_GIT_COMMIT_TIME
);
2529 memset(extended_info
->samba_version_string
, 0,
2530 sizeof(extended_info
->samba_version_string
));
2532 snprintf (extended_info
->samba_version_string
,
2533 sizeof(extended_info
->samba_version_string
),
2534 "%s", samba_version_string());
2537 /****************************************************************************
2538 Reply to a TRANS2_QFSINFO (query filesystem info).
2539 ****************************************************************************/
2541 static void call_trans2qfsinfo(connection_struct
*conn
,
2542 struct smb_request
*req
,
2543 char **pparams
, int total_params
,
2544 char **ppdata
, int total_data
,
2545 unsigned int max_data_bytes
)
2547 char *pdata
, *end_data
;
2548 char *params
= *pparams
;
2552 const char *vname
= volume_label(SNUM(conn
));
2553 int snum
= SNUM(conn
);
2554 char *fstype
= lp_fstype(SNUM(conn
));
2555 uint32 additional_flags
= 0;
2557 if (total_params
< 2) {
2558 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2562 info_level
= SVAL(params
,0);
2565 if (info_level
!= SMB_QUERY_CIFS_UNIX_INFO
) {
2566 DEBUG(0,("call_trans2qfsinfo: not an allowed "
2567 "info level (0x%x) on IPC$.\n",
2568 (unsigned int)info_level
));
2569 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
2574 if (ENCRYPTION_REQUIRED(conn
) && !req
->encrypted
) {
2575 if (info_level
!= SMB_QUERY_CIFS_UNIX_INFO
) {
2576 DEBUG(0,("call_trans2qfsinfo: encryption required "
2577 "and info level 0x%x sent.\n",
2578 (unsigned int)info_level
));
2579 exit_server_cleanly("encryption required "
2585 DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level
));
2587 if(SMB_VFS_STAT(conn
,".",&st
)!=0) {
2588 DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno
)));
2589 reply_doserror(req
, ERRSRV
, ERRinvdevice
);
2593 *ppdata
= (char *)SMB_REALLOC(
2594 *ppdata
, max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
);
2595 if (*ppdata
== NULL
) {
2596 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2601 memset((char *)pdata
,'\0',max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
);
2602 end_data
= pdata
+ max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
- 1;
2604 switch (info_level
) {
2605 case SMB_INFO_ALLOCATION
:
2607 SMB_BIG_UINT dfree
,dsize
,bsize
,block_size
,sectors_per_unit
,bytes_per_sector
;
2609 if (get_dfree_info(conn
,".",False
,&bsize
,&dfree
,&dsize
) == (SMB_BIG_UINT
)-1) {
2610 reply_unixerror(req
, ERRHRD
, ERRgeneral
);
2614 block_size
= lp_block_size(snum
);
2615 if (bsize
< block_size
) {
2616 SMB_BIG_UINT factor
= block_size
/bsize
;
2621 if (bsize
> block_size
) {
2622 SMB_BIG_UINT factor
= bsize
/block_size
;
2627 bytes_per_sector
= 512;
2628 sectors_per_unit
= bsize
/bytes_per_sector
;
2630 DEBUG(5,("call_trans2qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2631 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st
.st_dev
, (unsigned int)bsize
, (unsigned int)sectors_per_unit
,
2632 (unsigned int)bytes_per_sector
, (unsigned int)dsize
, (unsigned int)dfree
));
2634 SIVAL(pdata
,l1_idFileSystem
,st
.st_dev
);
2635 SIVAL(pdata
,l1_cSectorUnit
,sectors_per_unit
);
2636 SIVAL(pdata
,l1_cUnit
,dsize
);
2637 SIVAL(pdata
,l1_cUnitAvail
,dfree
);
2638 SSVAL(pdata
,l1_cbSector
,bytes_per_sector
);
2642 case SMB_INFO_VOLUME
:
2643 /* Return volume name */
2645 * Add volume serial number - hash of a combination of
2646 * the called hostname and the service name.
2648 SIVAL(pdata
,0,str_checksum(lp_servicename(snum
)) ^ (str_checksum(get_local_machine_name())<<16) );
2650 * Win2k3 and previous mess this up by sending a name length
2651 * one byte short. I believe only older clients (OS/2 Win9x) use
2652 * this call so try fixing this by adding a terminating null to
2653 * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2657 pdata
+l2_vol_szVolLabel
, vname
,
2658 PTR_DIFF(end_data
, pdata
+l2_vol_szVolLabel
),
2659 STR_NOALIGN
|STR_TERMINATE
);
2660 SCVAL(pdata
,l2_vol_cch
,len
);
2661 data_len
= l2_vol_szVolLabel
+ len
;
2662 DEBUG(5,("call_trans2qfsinfo : time = %x, namelen = %d, name = %s\n",
2663 (unsigned)st
.st_ctime
, len
, vname
));
2666 case SMB_QUERY_FS_ATTRIBUTE_INFO
:
2667 case SMB_FS_ATTRIBUTE_INFORMATION
:
2669 additional_flags
= 0;
2670 #if defined(HAVE_SYS_QUOTAS)
2671 additional_flags
|= FILE_VOLUME_QUOTAS
;
2674 if(lp_nt_acl_support(SNUM(conn
))) {
2675 additional_flags
|= FILE_PERSISTENT_ACLS
;
2678 /* Capabilities are filled in at connection time through STATVFS call */
2679 additional_flags
|= conn
->fs_capabilities
;
2681 SIVAL(pdata
,0,FILE_CASE_PRESERVED_NAMES
|FILE_CASE_SENSITIVE_SEARCH
|
2682 FILE_SUPPORTS_OBJECT_IDS
|FILE_UNICODE_ON_DISK
|
2683 additional_flags
); /* FS ATTRIBUTES */
2685 SIVAL(pdata
,4,255); /* Max filename component length */
2686 /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2687 and will think we can't do long filenames */
2688 len
= srvstr_push(pdata
, req
->flags2
, pdata
+12, fstype
,
2689 PTR_DIFF(end_data
, pdata
+12),
2692 data_len
= 12 + len
;
2695 case SMB_QUERY_FS_LABEL_INFO
:
2696 case SMB_FS_LABEL_INFORMATION
:
2697 len
= srvstr_push(pdata
, req
->flags2
, pdata
+4, vname
,
2698 PTR_DIFF(end_data
, pdata
+4), 0);
2703 case SMB_QUERY_FS_VOLUME_INFO
:
2704 case SMB_FS_VOLUME_INFORMATION
:
2707 * Add volume serial number - hash of a combination of
2708 * the called hostname and the service name.
2710 SIVAL(pdata
,8,str_checksum(lp_servicename(snum
)) ^
2711 (str_checksum(get_local_machine_name())<<16));
2713 /* Max label len is 32 characters. */
2714 len
= srvstr_push(pdata
, req
->flags2
, pdata
+18, vname
,
2715 PTR_DIFF(end_data
, pdata
+18),
2717 SIVAL(pdata
,12,len
);
2720 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
2721 (int)strlen(vname
),vname
, lp_servicename(snum
)));
2724 case SMB_QUERY_FS_SIZE_INFO
:
2725 case SMB_FS_SIZE_INFORMATION
:
2727 SMB_BIG_UINT dfree
,dsize
,bsize
,block_size
,sectors_per_unit
,bytes_per_sector
;
2729 if (get_dfree_info(conn
,".",False
,&bsize
,&dfree
,&dsize
) == (SMB_BIG_UINT
)-1) {
2730 reply_unixerror(req
, ERRHRD
, ERRgeneral
);
2733 block_size
= lp_block_size(snum
);
2734 if (bsize
< block_size
) {
2735 SMB_BIG_UINT factor
= block_size
/bsize
;
2740 if (bsize
> block_size
) {
2741 SMB_BIG_UINT factor
= bsize
/block_size
;
2746 bytes_per_sector
= 512;
2747 sectors_per_unit
= bsize
/bytes_per_sector
;
2748 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2749 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize
, (unsigned int)sectors_per_unit
,
2750 (unsigned int)bytes_per_sector
, (unsigned int)dsize
, (unsigned int)dfree
));
2751 SBIG_UINT(pdata
,0,dsize
);
2752 SBIG_UINT(pdata
,8,dfree
);
2753 SIVAL(pdata
,16,sectors_per_unit
);
2754 SIVAL(pdata
,20,bytes_per_sector
);
2758 case SMB_FS_FULL_SIZE_INFORMATION
:
2760 SMB_BIG_UINT dfree
,dsize
,bsize
,block_size
,sectors_per_unit
,bytes_per_sector
;
2762 if (get_dfree_info(conn
,".",False
,&bsize
,&dfree
,&dsize
) == (SMB_BIG_UINT
)-1) {
2763 reply_unixerror(req
, ERRHRD
, ERRgeneral
);
2766 block_size
= lp_block_size(snum
);
2767 if (bsize
< block_size
) {
2768 SMB_BIG_UINT factor
= block_size
/bsize
;
2773 if (bsize
> block_size
) {
2774 SMB_BIG_UINT factor
= bsize
/block_size
;
2779 bytes_per_sector
= 512;
2780 sectors_per_unit
= bsize
/bytes_per_sector
;
2781 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
2782 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize
, (unsigned int)sectors_per_unit
,
2783 (unsigned int)bytes_per_sector
, (unsigned int)dsize
, (unsigned int)dfree
));
2784 SBIG_UINT(pdata
,0,dsize
); /* Total Allocation units. */
2785 SBIG_UINT(pdata
,8,dfree
); /* Caller available allocation units. */
2786 SBIG_UINT(pdata
,16,dfree
); /* Actual available allocation units. */
2787 SIVAL(pdata
,24,sectors_per_unit
); /* Sectors per allocation unit. */
2788 SIVAL(pdata
,28,bytes_per_sector
); /* Bytes per sector. */
2792 case SMB_QUERY_FS_DEVICE_INFO
:
2793 case SMB_FS_DEVICE_INFORMATION
:
2795 SIVAL(pdata
,0,0); /* dev type */
2796 SIVAL(pdata
,4,0); /* characteristics */
2799 #ifdef HAVE_SYS_QUOTAS
2800 case SMB_FS_QUOTA_INFORMATION
:
2802 * what we have to send --metze:
2804 * Unknown1: 24 NULL bytes
2805 * Soft Quota Treshold: 8 bytes seems like SMB_BIG_UINT or so
2806 * Hard Quota Limit: 8 bytes seems like SMB_BIG_UINT or so
2807 * Quota Flags: 2 byte :
2808 * Unknown3: 6 NULL bytes
2812 * details for Quota Flags:
2814 * 0x0020 Log Limit: log if the user exceeds his Hard Quota
2815 * 0x0010 Log Warn: log if the user exceeds his Soft Quota
2816 * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
2817 * 0x0001 Enable Quotas: enable quota for this fs
2821 /* we need to fake up a fsp here,
2822 * because its not send in this call
2825 SMB_NTQUOTA_STRUCT quotas
;
2828 ZERO_STRUCT(quotas
);
2834 if (current_user
.ut
.uid
!= 0) {
2835 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
2836 lp_servicename(SNUM(conn
)),conn
->user
));
2837 reply_doserror(req
, ERRDOS
, ERRnoaccess
);
2841 if (vfs_get_ntquota(&fsp
, SMB_USER_FS_QUOTA_TYPE
, NULL
, "as
)!=0) {
2842 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn
))));
2843 reply_doserror(req
, ERRSRV
, ERRerror
);
2849 DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",lp_servicename(SNUM(conn
))));
2851 /* Unknown1 24 NULL bytes*/
2852 SBIG_UINT(pdata
,0,(SMB_BIG_UINT
)0);
2853 SBIG_UINT(pdata
,8,(SMB_BIG_UINT
)0);
2854 SBIG_UINT(pdata
,16,(SMB_BIG_UINT
)0);
2856 /* Default Soft Quota 8 bytes */
2857 SBIG_UINT(pdata
,24,quotas
.softlim
);
2859 /* Default Hard Quota 8 bytes */
2860 SBIG_UINT(pdata
,32,quotas
.hardlim
);
2862 /* Quota flag 2 bytes */
2863 SSVAL(pdata
,40,quotas
.qflags
);
2865 /* Unknown3 6 NULL bytes */
2871 #endif /* HAVE_SYS_QUOTAS */
2872 case SMB_FS_OBJECTID_INFORMATION
:
2874 unsigned char objid
[16];
2875 struct smb_extended_info extended_info
;
2876 memcpy(pdata
,create_volume_objectid(conn
, objid
),16);
2877 samba_extended_info_version (&extended_info
);
2878 SIVAL(pdata
,16,extended_info
.samba_magic
);
2879 SIVAL(pdata
,20,extended_info
.samba_version
);
2880 SIVAL(pdata
,24,extended_info
.samba_subversion
);
2881 SBIG_UINT(pdata
,28,extended_info
.samba_gitcommitdate
);
2882 memcpy(pdata
+36,extended_info
.samba_version_string
,28);
2888 * Query the version and capabilities of the CIFS UNIX extensions
2892 case SMB_QUERY_CIFS_UNIX_INFO
:
2894 bool large_write
= lp_min_receive_file_size() &&
2895 !srv_is_signing_active();
2896 bool large_read
= !srv_is_signing_active();
2897 int encrypt_caps
= 0;
2899 if (!lp_unix_extensions()) {
2900 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2904 switch (conn
->encrypt_level
) {
2910 encrypt_caps
= CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
;
2913 encrypt_caps
= CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
|
2914 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
;
2915 large_write
= false;
2921 SSVAL(pdata
,0,CIFS_UNIX_MAJOR_VERSION
);
2922 SSVAL(pdata
,2,CIFS_UNIX_MINOR_VERSION
);
2924 /* We have POSIX ACLs, pathname, encryption,
2925 * large read/write, and locking capability. */
2927 SBIG_UINT(pdata
,4,((SMB_BIG_UINT
)(
2928 CIFS_UNIX_POSIX_ACLS_CAP
|
2929 CIFS_UNIX_POSIX_PATHNAMES_CAP
|
2930 CIFS_UNIX_FCNTL_LOCKS_CAP
|
2931 CIFS_UNIX_EXTATTR_CAP
|
2932 CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP
|
2934 (large_read
? CIFS_UNIX_LARGE_READ_CAP
: 0) |
2936 CIFS_UNIX_LARGE_WRITE_CAP
: 0))));
2940 case SMB_QUERY_POSIX_FS_INFO
:
2943 vfs_statvfs_struct svfs
;
2945 if (!lp_unix_extensions()) {
2946 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2950 rc
= SMB_VFS_STATVFS(conn
, ".", &svfs
);
2954 SIVAL(pdata
,0,svfs
.OptimalTransferSize
);
2955 SIVAL(pdata
,4,svfs
.BlockSize
);
2956 SBIG_UINT(pdata
,8,svfs
.TotalBlocks
);
2957 SBIG_UINT(pdata
,16,svfs
.BlocksAvail
);
2958 SBIG_UINT(pdata
,24,svfs
.UserBlocksAvail
);
2959 SBIG_UINT(pdata
,32,svfs
.TotalFileNodes
);
2960 SBIG_UINT(pdata
,40,svfs
.FreeFileNodes
);
2961 SBIG_UINT(pdata
,48,svfs
.FsIdentifier
);
2962 DEBUG(5,("call_trans2qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
2964 } else if (rc
== EOPNOTSUPP
) {
2965 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2967 #endif /* EOPNOTSUPP */
2969 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn
))));
2970 reply_doserror(req
, ERRSRV
, ERRerror
);
2976 case SMB_QUERY_POSIX_WHOAMI
:
2982 if (!lp_unix_extensions()) {
2983 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2987 if (max_data_bytes
< 40) {
2988 reply_nterror(req
, NT_STATUS_BUFFER_TOO_SMALL
);
2992 /* We ARE guest if global_sid_Builtin_Guests is
2993 * in our list of SIDs.
2995 if (nt_token_check_sid(&global_sid_Builtin_Guests
,
2996 current_user
.nt_user_token
)) {
2997 flags
|= SMB_WHOAMI_GUEST
;
3000 /* We are NOT guest if global_sid_Authenticated_Users
3001 * is in our list of SIDs.
3003 if (nt_token_check_sid(&global_sid_Authenticated_Users
,
3004 current_user
.nt_user_token
)) {
3005 flags
&= ~SMB_WHOAMI_GUEST
;
3008 /* NOTE: 8 bytes for UID/GID, irrespective of native
3009 * platform size. This matches
3010 * SMB_QUERY_FILE_UNIX_BASIC and friends.
3012 data_len
= 4 /* flags */
3019 + 4 /* pad/reserved */
3020 + (current_user
.ut
.ngroups
* 8)
3022 + (current_user
.nt_user_token
->num_sids
*
3026 SIVAL(pdata
, 0, flags
);
3027 SIVAL(pdata
, 4, SMB_WHOAMI_MASK
);
3028 SBIG_UINT(pdata
, 8, (SMB_BIG_UINT
)current_user
.ut
.uid
);
3029 SBIG_UINT(pdata
, 16, (SMB_BIG_UINT
)current_user
.ut
.gid
);
3032 if (data_len
>= max_data_bytes
) {
3033 /* Potential overflow, skip the GIDs and SIDs. */
3035 SIVAL(pdata
, 24, 0); /* num_groups */
3036 SIVAL(pdata
, 28, 0); /* num_sids */
3037 SIVAL(pdata
, 32, 0); /* num_sid_bytes */
3038 SIVAL(pdata
, 36, 0); /* reserved */
3044 SIVAL(pdata
, 24, current_user
.ut
.ngroups
);
3046 current_user
.nt_user_token
->num_sids
);
3048 /* We walk the SID list twice, but this call is fairly
3049 * infrequent, and I don't expect that it's performance
3050 * sensitive -- jpeach
3052 for (i
= 0, sid_bytes
= 0;
3053 i
< current_user
.nt_user_token
->num_sids
; ++i
) {
3054 sid_bytes
+= ndr_size_dom_sid(
3055 ¤t_user
.nt_user_token
->user_sids
[i
], 0);
3058 /* SID list byte count */
3059 SIVAL(pdata
, 32, sid_bytes
);
3061 /* 4 bytes pad/reserved - must be zero */
3062 SIVAL(pdata
, 36, 0);
3066 for (i
= 0; i
< current_user
.ut
.ngroups
; ++i
) {
3067 SBIG_UINT(pdata
, data_len
,
3068 (SMB_BIG_UINT
)current_user
.ut
.groups
[i
]);
3074 i
< current_user
.nt_user_token
->num_sids
; ++i
) {
3075 int sid_len
= ndr_size_dom_sid(
3076 ¤t_user
.nt_user_token
->user_sids
[i
], 0);
3078 sid_linearize(pdata
+ data_len
, sid_len
,
3079 ¤t_user
.nt_user_token
->user_sids
[i
]);
3080 data_len
+= sid_len
;
3086 case SMB_MAC_QUERY_FS_INFO
:
3088 * Thursby MAC extension... ONLY on NTFS filesystems
3089 * once we do streams then we don't need this
3091 if (strequal(lp_fstype(SNUM(conn
)),"NTFS")) {
3093 SIVAL(pdata
,84,0x100); /* Don't support mac... */
3098 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
3103 send_trans2_replies(conn
, req
, params
, 0, pdata
, data_len
,
3106 DEBUG( 4, ( "%s info_level = %d\n",
3107 smb_fn_name(CVAL(req
->inbuf
,smb_com
)), info_level
) );
3112 /****************************************************************************
3113 Reply to a TRANS2_SETFSINFO (set filesystem info).
3114 ****************************************************************************/
3116 static void call_trans2setfsinfo(connection_struct
*conn
,
3117 struct smb_request
*req
,
3118 char **pparams
, int total_params
,
3119 char **ppdata
, int total_data
,
3120 unsigned int max_data_bytes
)
3122 char *pdata
= *ppdata
;
3123 char *params
= *pparams
;
3126 DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn
))));
3129 if (total_params
< 4) {
3130 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
3132 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
3136 info_level
= SVAL(params
,2);
3139 if (info_level
!= SMB_REQUEST_TRANSPORT_ENCRYPTION
&&
3140 info_level
!= SMB_SET_CIFS_UNIX_INFO
) {
3141 DEBUG(0,("call_trans2setfsinfo: not an allowed "
3142 "info level (0x%x) on IPC$.\n",
3143 (unsigned int)info_level
));
3144 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
3149 if (ENCRYPTION_REQUIRED(conn
) && !req
->encrypted
) {
3150 if (info_level
!= SMB_REQUEST_TRANSPORT_ENCRYPTION
) {
3151 DEBUG(0,("call_trans2setfsinfo: encryption required "
3152 "and info level 0x%x sent.\n",
3153 (unsigned int)info_level
));
3154 exit_server_cleanly("encryption required "
3160 switch(info_level
) {
3161 case SMB_SET_CIFS_UNIX_INFO
:
3163 uint16 client_unix_major
;
3164 uint16 client_unix_minor
;
3165 uint32 client_unix_cap_low
;
3166 uint32 client_unix_cap_high
;
3168 if (!lp_unix_extensions()) {
3170 NT_STATUS_INVALID_LEVEL
);
3174 /* There should be 12 bytes of capabilities set. */
3175 if (total_data
< 8) {
3178 NT_STATUS_INVALID_PARAMETER
);
3181 client_unix_major
= SVAL(pdata
,0);
3182 client_unix_minor
= SVAL(pdata
,2);
3183 client_unix_cap_low
= IVAL(pdata
,4);
3184 client_unix_cap_high
= IVAL(pdata
,8);
3185 /* Just print these values for now. */
3186 DEBUG(10,("call_trans2setfsinfo: set unix info. major = %u, minor = %u \
3187 cap_low = 0x%x, cap_high = 0x%x\n",
3188 (unsigned int)client_unix_major
,
3189 (unsigned int)client_unix_minor
,
3190 (unsigned int)client_unix_cap_low
,
3191 (unsigned int)client_unix_cap_high
));
3193 /* Here is where we must switch to posix pathname processing... */
3194 if (client_unix_cap_low
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3195 lp_set_posix_pathnames();
3196 mangle_change_to_posix();
3199 if ((client_unix_cap_low
& CIFS_UNIX_FCNTL_LOCKS_CAP
) &&
3200 !(client_unix_cap_low
& CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP
)) {
3201 /* Client that knows how to do posix locks,
3202 * but not posix open/mkdir operations. Set a
3203 * default type for read/write checks. */
3205 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK
);
3211 case SMB_REQUEST_TRANSPORT_ENCRYPTION
:
3214 size_t param_len
= 0;
3215 size_t data_len
= total_data
;
3217 if (!lp_unix_extensions()) {
3220 NT_STATUS_INVALID_LEVEL
);
3224 if (lp_smb_encrypt(SNUM(conn
)) == false) {
3227 NT_STATUS_NOT_SUPPORTED
);
3231 DEBUG( 4,("call_trans2setfsinfo: "
3232 "request transport encryption.\n"));
3234 status
= srv_request_encryption_setup(conn
,
3235 (unsigned char **)ppdata
,
3237 (unsigned char **)pparams
,
3240 if (!NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
) &&
3241 !NT_STATUS_IS_OK(status
)) {
3242 reply_nterror(req
, status
);
3246 send_trans2_replies(conn
, req
,
3253 if (NT_STATUS_IS_OK(status
)) {
3254 /* Server-side transport
3255 * encryption is now *on*. */
3256 status
= srv_encryption_start(conn
);
3257 if (!NT_STATUS_IS_OK(status
)) {
3258 exit_server_cleanly(
3259 "Failure in setting "
3260 "up encrypted transport");
3266 case SMB_FS_QUOTA_INFORMATION
:
3268 files_struct
*fsp
= NULL
;
3269 SMB_NTQUOTA_STRUCT quotas
;
3271 ZERO_STRUCT(quotas
);
3274 if ((current_user
.ut
.uid
!= 0)||!CAN_WRITE(conn
)) {
3275 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
3276 lp_servicename(SNUM(conn
)),conn
->user
));
3277 reply_doserror(req
, ERRSRV
, ERRaccess
);
3281 /* note: normaly there're 48 bytes,
3282 * but we didn't use the last 6 bytes for now
3285 fsp
= file_fsp(SVAL(params
,0));
3286 if (!CHECK_NTQUOTA_HANDLE_OK(fsp
,conn
)) {
3287 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
3289 req
, NT_STATUS_INVALID_HANDLE
);
3293 if (total_data
< 42) {
3294 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
3298 NT_STATUS_INVALID_PARAMETER
);
3302 /* unknown_1 24 NULL bytes in pdata*/
3304 /* the soft quotas 8 bytes (SMB_BIG_UINT)*/
3305 quotas
.softlim
= (SMB_BIG_UINT
)IVAL(pdata
,24);
3306 #ifdef LARGE_SMB_OFF_T
3307 quotas
.softlim
|= (((SMB_BIG_UINT
)IVAL(pdata
,28)) << 32);
3308 #else /* LARGE_SMB_OFF_T */
3309 if ((IVAL(pdata
,28) != 0)&&
3310 ((quotas
.softlim
!= 0xFFFFFFFF)||
3311 (IVAL(pdata
,28)!=0xFFFFFFFF))) {
3312 /* more than 32 bits? */
3315 NT_STATUS_INVALID_PARAMETER
);
3318 #endif /* LARGE_SMB_OFF_T */
3320 /* the hard quotas 8 bytes (SMB_BIG_UINT)*/
3321 quotas
.hardlim
= (SMB_BIG_UINT
)IVAL(pdata
,32);
3322 #ifdef LARGE_SMB_OFF_T
3323 quotas
.hardlim
|= (((SMB_BIG_UINT
)IVAL(pdata
,36)) << 32);
3324 #else /* LARGE_SMB_OFF_T */
3325 if ((IVAL(pdata
,36) != 0)&&
3326 ((quotas
.hardlim
!= 0xFFFFFFFF)||
3327 (IVAL(pdata
,36)!=0xFFFFFFFF))) {
3328 /* more than 32 bits? */
3331 NT_STATUS_INVALID_PARAMETER
);
3334 #endif /* LARGE_SMB_OFF_T */
3336 /* quota_flags 2 bytes **/
3337 quotas
.qflags
= SVAL(pdata
,40);
3339 /* unknown_2 6 NULL bytes follow*/
3341 /* now set the quotas */
3342 if (vfs_set_ntquota(fsp
, SMB_USER_FS_QUOTA_TYPE
, NULL
, "as
)!=0) {
3343 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn
))));
3344 reply_doserror(req
, ERRSRV
, ERRerror
);
3351 DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
3353 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
3359 * sending this reply works fine,
3360 * but I'm not sure it's the same
3361 * like windows do...
3364 reply_outbuf(req
, 10, 0);
3367 #if defined(HAVE_POSIX_ACLS)
3368 /****************************************************************************
3369 Utility function to count the number of entries in a POSIX acl.
3370 ****************************************************************************/
3372 static unsigned int count_acl_entries(connection_struct
*conn
, SMB_ACL_T posix_acl
)
3374 unsigned int ace_count
= 0;
3375 int entry_id
= SMB_ACL_FIRST_ENTRY
;
3376 SMB_ACL_ENTRY_T entry
;
3378 while ( posix_acl
&& (SMB_VFS_SYS_ACL_GET_ENTRY(conn
, posix_acl
, entry_id
, &entry
) == 1)) {
3380 if (entry_id
== SMB_ACL_FIRST_ENTRY
) {
3381 entry_id
= SMB_ACL_NEXT_ENTRY
;
3388 /****************************************************************************
3389 Utility function to marshall a POSIX acl into wire format.
3390 ****************************************************************************/
3392 static bool marshall_posix_acl(connection_struct
*conn
, char *pdata
, SMB_STRUCT_STAT
*pst
, SMB_ACL_T posix_acl
)
3394 int entry_id
= SMB_ACL_FIRST_ENTRY
;
3395 SMB_ACL_ENTRY_T entry
;
3397 while ( posix_acl
&& (SMB_VFS_SYS_ACL_GET_ENTRY(conn
, posix_acl
, entry_id
, &entry
) == 1)) {
3398 SMB_ACL_TAG_T tagtype
;
3399 SMB_ACL_PERMSET_T permset
;
3400 unsigned char perms
= 0;
3401 unsigned int own_grp
;
3404 if (entry_id
== SMB_ACL_FIRST_ENTRY
) {
3405 entry_id
= SMB_ACL_NEXT_ENTRY
;
3408 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn
, entry
, &tagtype
) == -1) {
3409 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
3413 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn
, entry
, &permset
) == -1) {
3414 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
3418 perms
|= (SMB_VFS_SYS_ACL_GET_PERM(conn
, permset
, SMB_ACL_READ
) ? SMB_POSIX_ACL_READ
: 0);
3419 perms
|= (SMB_VFS_SYS_ACL_GET_PERM(conn
, permset
, SMB_ACL_WRITE
) ? SMB_POSIX_ACL_WRITE
: 0);
3420 perms
|= (SMB_VFS_SYS_ACL_GET_PERM(conn
, permset
, SMB_ACL_EXECUTE
) ? SMB_POSIX_ACL_EXECUTE
: 0);
3422 SCVAL(pdata
,1,perms
);
3425 case SMB_ACL_USER_OBJ
:
3426 SCVAL(pdata
,0,SMB_POSIX_ACL_USER_OBJ
);
3427 own_grp
= (unsigned int)pst
->st_uid
;
3428 SIVAL(pdata
,2,own_grp
);
3433 uid_t
*puid
= (uid_t
*)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn
, entry
);
3435 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3438 own_grp
= (unsigned int)*puid
;
3439 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn
, (void *)puid
,tagtype
);
3440 SCVAL(pdata
,0,SMB_POSIX_ACL_USER
);
3441 SIVAL(pdata
,2,own_grp
);
3445 case SMB_ACL_GROUP_OBJ
:
3446 SCVAL(pdata
,0,SMB_POSIX_ACL_GROUP_OBJ
);
3447 own_grp
= (unsigned int)pst
->st_gid
;
3448 SIVAL(pdata
,2,own_grp
);
3453 gid_t
*pgid
= (gid_t
*)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn
, entry
);
3455 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3458 own_grp
= (unsigned int)*pgid
;
3459 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn
, (void *)pgid
,tagtype
);
3460 SCVAL(pdata
,0,SMB_POSIX_ACL_GROUP
);
3461 SIVAL(pdata
,2,own_grp
);
3466 SCVAL(pdata
,0,SMB_POSIX_ACL_MASK
);
3467 SIVAL(pdata
,2,0xFFFFFFFF);
3468 SIVAL(pdata
,6,0xFFFFFFFF);
3471 SCVAL(pdata
,0,SMB_POSIX_ACL_OTHER
);
3472 SIVAL(pdata
,2,0xFFFFFFFF);
3473 SIVAL(pdata
,6,0xFFFFFFFF);
3476 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
3479 pdata
+= SMB_POSIX_ACL_ENTRY_SIZE
;
3486 /****************************************************************************
3487 Store the FILE_UNIX_BASIC info.
3488 ****************************************************************************/
3490 static char *store_file_unix_basic(connection_struct
*conn
,
3493 const SMB_STRUCT_STAT
*psbuf
)
3495 DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
3496 DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf
->st_mode
));
3498 SOFF_T(pdata
,0,get_file_size(*psbuf
)); /* File size 64 Bit */
3501 SOFF_T(pdata
,0,get_allocation_size(conn
,fsp
,psbuf
)); /* Number of bytes used on disk - 64 Bit */
3504 put_long_date_timespec(pdata
,get_ctimespec(psbuf
)); /* Change Time 64 Bit */
3505 put_long_date_timespec(pdata
+8,get_atimespec(psbuf
)); /* Last access time 64 Bit */
3506 put_long_date_timespec(pdata
+16,get_mtimespec(psbuf
)); /* Last modification time 64 Bit */
3509 SIVAL(pdata
,0,psbuf
->st_uid
); /* user id for the owner */
3513 SIVAL(pdata
,0,psbuf
->st_gid
); /* group id of owner */
3517 SIVAL(pdata
,0,unix_filetype(psbuf
->st_mode
));
3520 SIVAL(pdata
,0,unix_dev_major(psbuf
->st_rdev
)); /* Major device number if type is device */
3524 SIVAL(pdata
,0,unix_dev_minor(psbuf
->st_rdev
)); /* Minor device number if type is device */
3528 SINO_T_VAL(pdata
,0,(SMB_INO_T
)psbuf
->st_ino
); /* inode number */
3531 SIVAL(pdata
,0, unix_perms_to_wire(psbuf
->st_mode
)); /* Standard UNIX file permissions */
3535 SIVAL(pdata
,0,psbuf
->st_nlink
); /* number of hard links */
3542 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
3543 * the chflags(2) (or equivalent) flags.
3545 * XXX: this really should be behind the VFS interface. To do this, we would
3546 * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
3547 * Each VFS module could then implement its own mapping as appropriate for the
3548 * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
3550 static const struct {unsigned stat_fflag
; unsigned smb_fflag
;}
3554 { UF_NODUMP
, EXT_DO_NOT_BACKUP
},
3558 { UF_IMMUTABLE
, EXT_IMMUTABLE
},
3562 { UF_APPEND
, EXT_OPEN_APPEND_ONLY
},
3566 { UF_HIDDEN
, EXT_HIDDEN
},
3569 /* Do not remove. We need to guarantee that this array has at least one
3570 * entry to build on HP-UX.
3576 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT
*psbuf
,
3577 uint32
*smb_fflags
, uint32
*smb_fmask
)
3579 #ifdef HAVE_STAT_ST_FLAGS
3582 for (i
= 0; i
< ARRAY_SIZE(info2_flags_map
); ++i
) {
3583 *smb_fmask
|= info2_flags_map
[i
].smb_fflag
;
3584 if (psbuf
->st_flags
& info2_flags_map
[i
].stat_fflag
) {
3585 *smb_fflags
|= info2_flags_map
[i
].smb_fflag
;
3588 #endif /* HAVE_STAT_ST_FLAGS */
3591 static bool map_info2_flags_to_sbuf(const SMB_STRUCT_STAT
*psbuf
,
3592 const uint32 smb_fflags
,
3593 const uint32 smb_fmask
,
3596 #ifdef HAVE_STAT_ST_FLAGS
3597 uint32 max_fmask
= 0;
3600 *stat_fflags
= psbuf
->st_flags
;
3602 /* For each flags requested in smb_fmask, check the state of the
3603 * corresponding flag in smb_fflags and set or clear the matching
3607 for (i
= 0; i
< ARRAY_SIZE(info2_flags_map
); ++i
) {
3608 max_fmask
|= info2_flags_map
[i
].smb_fflag
;
3609 if (smb_fmask
& info2_flags_map
[i
].smb_fflag
) {
3610 if (smb_fflags
& info2_flags_map
[i
].smb_fflag
) {
3611 *stat_fflags
|= info2_flags_map
[i
].stat_fflag
;
3613 *stat_fflags
&= ~info2_flags_map
[i
].stat_fflag
;
3618 /* If smb_fmask is asking to set any bits that are not supported by
3619 * our flag mappings, we should fail.
3621 if ((smb_fmask
& max_fmask
) != smb_fmask
) {
3628 #endif /* HAVE_STAT_ST_FLAGS */
3632 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
3633 * of file flags and birth (create) time.
3635 static char *store_file_unix_basic_info2(connection_struct
*conn
,
3638 const SMB_STRUCT_STAT
*psbuf
)
3640 uint32 file_flags
= 0;
3641 uint32 flags_mask
= 0;
3643 pdata
= store_file_unix_basic(conn
, pdata
, fsp
, psbuf
);
3645 /* Create (birth) time 64 bit */
3646 put_long_date_timespec(pdata
, get_create_timespec(psbuf
, False
));
3649 map_info2_flags_from_sbuf(psbuf
, &file_flags
, &flags_mask
);
3650 SIVAL(pdata
, 0, file_flags
); /* flags */
3651 SIVAL(pdata
, 4, flags_mask
); /* mask */
3657 static NTSTATUS
marshall_stream_info(unsigned int num_streams
,
3658 const struct stream_struct
*streams
,
3660 unsigned int max_data_bytes
,
3661 unsigned int *data_size
)
3664 unsigned int ofs
= 0;
3666 for (i
= 0; i
< num_streams
&& ofs
<= max_data_bytes
; i
++) {
3667 unsigned int next_offset
;
3669 smb_ucs2_t
*namebuf
;
3671 namelen
= push_ucs2_talloc(talloc_tos(), &namebuf
,
3674 if ((namelen
== (size_t)-1) || (namelen
<= 2)) {
3675 return NT_STATUS_INVALID_PARAMETER
;
3679 * name_buf is now null-terminated, we need to marshall as not
3685 SIVAL(data
, ofs
+4, namelen
);
3686 SOFF_T(data
, ofs
+8, streams
[i
].size
);
3687 SOFF_T(data
, ofs
+16, streams
[i
].alloc_size
);
3688 memcpy(data
+ofs
+24, namebuf
, namelen
);
3689 TALLOC_FREE(namebuf
);
3691 next_offset
= ofs
+ 24 + namelen
;
3693 if (i
== num_streams
-1) {
3694 SIVAL(data
, ofs
, 0);
3697 unsigned int align
= ndr_align_size(next_offset
, 8);
3699 memset(data
+next_offset
, 0, align
);
3700 next_offset
+= align
;
3702 SIVAL(data
, ofs
, next_offset
- ofs
);
3711 return NT_STATUS_OK
;
3714 /****************************************************************************
3715 Reply to a TRANSACT2_QFILEINFO on a PIPE !
3716 ****************************************************************************/
3718 static void call_trans2qpipeinfo(connection_struct
*conn
,
3719 struct smb_request
*req
,
3720 unsigned int tran_call
,
3721 char **pparams
, int total_params
,
3722 char **ppdata
, int total_data
,
3723 unsigned int max_data_bytes
)
3725 char *params
= *pparams
;
3726 char *pdata
= *ppdata
;
3727 unsigned int data_size
= 0;
3728 unsigned int param_size
= 2;
3730 smb_np_struct
*p_pipe
= NULL
;
3733 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
3737 if (total_params
< 4) {
3738 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
3742 p_pipe
= get_rpc_pipe_p(SVAL(params
,0));
3743 if (p_pipe
== NULL
) {
3744 reply_nterror(req
, NT_STATUS_INVALID_HANDLE
);
3748 info_level
= SVAL(params
,2);
3750 *pparams
= (char *)SMB_REALLOC(*pparams
,2);
3751 if (*pparams
== NULL
) {
3752 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
3757 data_size
= max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
;
3758 *ppdata
= (char *)SMB_REALLOC(*ppdata
, data_size
);
3759 if (*ppdata
== NULL
) {
3760 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
3765 switch (info_level
) {
3766 case SMB_FILE_STANDARD_INFORMATION
:
3768 SOFF_T(pdata
,0,4096LL);
3775 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
3779 send_trans2_replies(conn
, req
, params
, param_size
, *ppdata
, data_size
,
3785 /****************************************************************************
3786 Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
3787 file name or file id).
3788 ****************************************************************************/
3790 static void call_trans2qfilepathinfo(connection_struct
*conn
,
3791 struct smb_request
*req
,
3792 unsigned int tran_call
,
3793 char **pparams
, int total_params
,
3794 char **ppdata
, int total_data
,
3795 unsigned int max_data_bytes
)
3797 char *params
= *pparams
;
3798 char *pdata
= *ppdata
;
3799 char *dstart
, *dend
;
3803 SMB_OFF_T file_size
=0;
3804 SMB_BIG_UINT allocation_size
=0;
3805 unsigned int data_size
= 0;
3806 unsigned int param_size
= 2;
3807 SMB_STRUCT_STAT sbuf
;
3808 char *dos_fname
= NULL
;
3814 bool delete_pending
= False
;
3816 time_t create_time
, mtime
, atime
;
3817 struct timespec create_time_ts
, mtime_ts
, atime_ts
;
3818 struct timespec write_time_ts
;
3819 files_struct
*fsp
= NULL
;
3820 struct file_id fileid
;
3821 struct ea_list
*ea_list
= NULL
;
3822 uint32 access_mask
= 0x12019F; /* Default - GENERIC_EXECUTE mapping from Windows */
3823 char *lock_data
= NULL
;
3824 bool ms_dfs_link
= false;
3825 TALLOC_CTX
*ctx
= talloc_tos();
3828 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
3833 ZERO_STRUCT(write_time_ts
);
3835 if (tran_call
== TRANSACT2_QFILEINFO
) {
3836 if (total_params
< 4) {
3837 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
3842 call_trans2qpipeinfo(conn
, req
, tran_call
,
3843 pparams
, total_params
,
3849 fsp
= file_fsp(SVAL(params
,0));
3850 info_level
= SVAL(params
,2);
3852 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level
));
3854 if (INFO_LEVEL_IS_UNIX(info_level
) && !lp_unix_extensions()) {
3855 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
3859 /* Initial check for valid fsp ptr. */
3860 if (!check_fsp_open(conn
, req
, fsp
, ¤t_user
)) {
3864 fname
= talloc_strdup(talloc_tos(),fsp
->fsp_name
);
3866 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
3870 if(fsp
->fake_file_handle
) {
3872 * This is actually for the QUOTA_FAKE_FILE --metze
3875 /* We know this name is ok, it's already passed the checks. */
3877 } else if(fsp
&& (fsp
->is_directory
|| fsp
->fh
->fd
== -1)) {
3879 * This is actually a QFILEINFO on a directory
3880 * handle (returned from an NT SMB). NT5.0 seems
3881 * to do this call. JRA.
3884 if (INFO_LEVEL_IS_UNIX(info_level
)) {
3885 /* Always do lstat for UNIX calls. */
3886 if (SMB_VFS_LSTAT(conn
,fname
,&sbuf
)) {
3887 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname
,strerror(errno
)));
3888 reply_unixerror(req
,ERRDOS
,ERRbadpath
);
3891 } else if (SMB_VFS_STAT(conn
,fname
,&sbuf
)) {
3892 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname
,strerror(errno
)));
3893 reply_unixerror(req
, ERRDOS
, ERRbadpath
);
3897 fileid
= vfs_file_id_from_sbuf(conn
, &sbuf
);
3898 get_file_infos(fileid
, &delete_pending
, &write_time_ts
);
3901 * Original code - this is an open file.
3903 if (!check_fsp(conn
, req
, fsp
, ¤t_user
)) {
3907 if (SMB_VFS_FSTAT(fsp
, &sbuf
) != 0) {
3908 DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp
->fnum
, strerror(errno
)));
3909 reply_unixerror(req
, ERRDOS
, ERRbadfid
);
3912 pos
= fsp
->fh
->position_information
;
3913 fileid
= vfs_file_id_from_sbuf(conn
, &sbuf
);
3914 get_file_infos(fileid
, &delete_pending
, &write_time_ts
);
3915 access_mask
= fsp
->access_mask
;
3919 NTSTATUS status
= NT_STATUS_OK
;
3922 if (total_params
< 7) {
3923 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
3927 info_level
= SVAL(params
,0);
3929 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level
));
3931 if (INFO_LEVEL_IS_UNIX(info_level
) && !lp_unix_extensions()) {
3932 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
3936 srvstr_get_path(ctx
, params
, req
->flags2
, &fname
, ¶ms
[6],
3938 STR_TERMINATE
, &status
);
3939 if (!NT_STATUS_IS_OK(status
)) {
3940 reply_nterror(req
, status
);
3944 status
= resolve_dfspath(ctx
,
3946 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
3949 if (!NT_STATUS_IS_OK(status
)) {
3950 if (NT_STATUS_EQUAL(status
,NT_STATUS_PATH_NOT_COVERED
)) {
3951 reply_botherror(req
,
3952 NT_STATUS_PATH_NOT_COVERED
,
3953 ERRSRV
, ERRbadpath
);
3955 reply_nterror(req
, status
);
3959 status
= unix_convert(ctx
, conn
, fname
, False
, &fname
, NULL
, &sbuf
);
3960 if (!NT_STATUS_IS_OK(status
)) {
3961 reply_nterror(req
, status
);
3964 status
= check_name(conn
, fname
);
3965 if (!NT_STATUS_IS_OK(status
)) {
3966 DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",fname
,nt_errstr(status
)));
3967 reply_nterror(req
, status
);
3971 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
3972 && is_ntfs_stream_name(fname
)) {
3974 SMB_STRUCT_STAT bsbuf
;
3976 status
= split_ntfs_stream_name(talloc_tos(), fname
,
3978 if (!NT_STATUS_IS_OK(status
)) {
3979 DEBUG(10, ("create_file_unixpath: "
3980 "split_ntfs_stream_name failed: %s\n",
3981 nt_errstr(status
)));
3982 reply_nterror(req
, status
);
3986 SMB_ASSERT(!is_ntfs_stream_name(base
)); /* paranoia.. */
3988 if (INFO_LEVEL_IS_UNIX(info_level
)) {
3989 /* Always do lstat for UNIX calls. */
3990 if (SMB_VFS_LSTAT(conn
,base
,&bsbuf
)) {
3991 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",base
,strerror(errno
)));
3992 reply_unixerror(req
,ERRDOS
,ERRbadpath
);
3996 if (SMB_VFS_STAT(conn
,base
,&bsbuf
) != 0) {
3997 DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",base
,strerror(errno
)));
3998 reply_unixerror(req
,ERRDOS
,ERRbadpath
);
4003 fileid
= vfs_file_id_from_sbuf(conn
, &bsbuf
);
4004 get_file_infos(fileid
, &delete_pending
, NULL
);
4005 if (delete_pending
) {
4006 reply_nterror(req
, NT_STATUS_DELETE_PENDING
);
4011 if (INFO_LEVEL_IS_UNIX(info_level
)) {
4012 /* Always do lstat for UNIX calls. */
4013 if (SMB_VFS_LSTAT(conn
,fname
,&sbuf
)) {
4014 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname
,strerror(errno
)));
4015 reply_unixerror(req
, ERRDOS
, ERRbadpath
);
4019 } else if (!VALID_STAT(sbuf
) && SMB_VFS_STAT(conn
,fname
,&sbuf
) && (info_level
!= SMB_INFO_IS_NAME_VALID
)) {
4020 ms_dfs_link
= check_msdfs_link(conn
,fname
,&sbuf
);
4023 DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname
,strerror(errno
)));
4024 reply_unixerror(req
, ERRDOS
, ERRbadpath
);
4029 fileid
= vfs_file_id_from_sbuf(conn
, &sbuf
);
4030 get_file_infos(fileid
, &delete_pending
, &write_time_ts
);
4031 if (delete_pending
) {
4032 reply_nterror(req
, NT_STATUS_DELETE_PENDING
);
4037 if (INFO_LEVEL_IS_UNIX(info_level
) && !lp_unix_extensions()) {
4038 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
4042 DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d total_data=%d\n",
4043 fname
,fsp
? fsp
->fnum
: -1, info_level
,tran_call
,total_data
));
4045 p
= strrchr_m(fname
,'/');
4052 mode
= dos_mode_msdfs(conn
,fname
,&sbuf
);
4054 mode
= dos_mode(conn
,fname
,&sbuf
);
4057 mode
= FILE_ATTRIBUTE_NORMAL
;
4059 nlink
= sbuf
.st_nlink
;
4061 if (nlink
&& (mode
&aDIR
)) {
4065 if ((nlink
> 0) && delete_pending
) {
4069 fullpathname
= fname
;
4071 file_size
= get_file_size(sbuf
);
4073 /* Pull out any data sent here before we realloc. */
4074 switch (info_level
) {
4075 case SMB_INFO_QUERY_EAS_FROM_LIST
:
4077 /* Pull any EA list from the data portion. */
4080 if (total_data
< 4) {
4082 req
, NT_STATUS_INVALID_PARAMETER
);
4085 ea_size
= IVAL(pdata
,0);
4087 if (total_data
> 0 && ea_size
!= total_data
) {
4088 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
4089 total_data=%u (should be %u)\n", (unsigned int)total_data
, (unsigned int)IVAL(pdata
,0) ));
4091 req
, NT_STATUS_INVALID_PARAMETER
);
4095 if (!lp_ea_support(SNUM(conn
))) {
4096 reply_doserror(req
, ERRDOS
,
4097 ERReasnotsupported
);
4101 /* Pull out the list of names. */
4102 ea_list
= read_ea_name_list(ctx
, pdata
+ 4, ea_size
- 4);
4105 req
, NT_STATUS_INVALID_PARAMETER
);
4111 case SMB_QUERY_POSIX_LOCK
:
4113 if (fsp
== NULL
|| fsp
->fh
->fd
== -1) {
4114 reply_nterror(req
, NT_STATUS_INVALID_HANDLE
);
4118 if (total_data
!= POSIX_LOCK_DATA_SIZE
) {
4120 req
, NT_STATUS_INVALID_PARAMETER
);
4124 /* Copy the lock range data. */
4125 lock_data
= (char *)TALLOC_MEMDUP(
4126 ctx
, pdata
, total_data
);
4128 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
4136 *pparams
= (char *)SMB_REALLOC(*pparams
,2);
4137 if (*pparams
== NULL
) {
4138 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
4143 data_size
= max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
;
4144 *ppdata
= (char *)SMB_REALLOC(*ppdata
, data_size
);
4145 if (*ppdata
== NULL
) {
4146 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
4151 dend
= dstart
+ data_size
- 1;
4153 create_time_ts
= get_create_timespec(&sbuf
,lp_fake_dir_create_times(SNUM(conn
)));
4154 mtime_ts
= get_mtimespec(&sbuf
);
4155 atime_ts
= get_atimespec(&sbuf
);
4157 allocation_size
= get_allocation_size(conn
,fsp
,&sbuf
);
4160 /* Do we have this path open ? */
4162 fileid
= vfs_file_id_from_sbuf(conn
, &sbuf
);
4163 fsp1
= file_find_di_first(fileid
);
4164 if (fsp1
&& fsp1
->initial_allocation_size
) {
4165 allocation_size
= get_allocation_size(conn
, fsp1
, &sbuf
);
4169 if (!null_timespec(write_time_ts
) && !INFO_LEVEL_IS_UNIX(info_level
)) {
4170 mtime_ts
= write_time_ts
;
4173 if (lp_dos_filetime_resolution(SNUM(conn
))) {
4174 dos_filetime_timespec(&create_time_ts
);
4175 dos_filetime_timespec(&mtime_ts
);
4176 dos_filetime_timespec(&atime_ts
);
4179 create_time
= convert_timespec_to_time_t(create_time_ts
);
4180 mtime
= convert_timespec_to_time_t(mtime_ts
);
4181 atime
= convert_timespec_to_time_t(atime_ts
);
4183 /* NT expects the name to be in an exact form of the *full*
4184 filename. See the trans2 torture test */
4185 if (ISDOT(base_name
)) {
4186 dos_fname
= talloc_strdup(ctx
, "\\");
4188 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
4192 dos_fname
= talloc_asprintf(ctx
,
4196 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
4199 string_replace(dos_fname
, '/', '\\');
4202 switch (info_level
) {
4203 case SMB_INFO_STANDARD
:
4204 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_STANDARD\n"));
4206 srv_put_dos_date2(pdata
,l1_fdateCreation
,create_time
);
4207 srv_put_dos_date2(pdata
,l1_fdateLastAccess
,atime
);
4208 srv_put_dos_date2(pdata
,l1_fdateLastWrite
,mtime
); /* write time */
4209 SIVAL(pdata
,l1_cbFile
,(uint32
)file_size
);
4210 SIVAL(pdata
,l1_cbFileAlloc
,(uint32
)allocation_size
);
4211 SSVAL(pdata
,l1_attrFile
,mode
);
4214 case SMB_INFO_QUERY_EA_SIZE
:
4216 unsigned int ea_size
= estimate_ea_size(conn
, fsp
, fname
);
4217 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
4219 srv_put_dos_date2(pdata
,0,create_time
);
4220 srv_put_dos_date2(pdata
,4,atime
);
4221 srv_put_dos_date2(pdata
,8,mtime
); /* write time */
4222 SIVAL(pdata
,12,(uint32
)file_size
);
4223 SIVAL(pdata
,16,(uint32
)allocation_size
);
4224 SSVAL(pdata
,20,mode
);
4225 SIVAL(pdata
,22,ea_size
);
4229 case SMB_INFO_IS_NAME_VALID
:
4230 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
4231 if (tran_call
== TRANSACT2_QFILEINFO
) {
4232 /* os/2 needs this ? really ?*/
4233 reply_doserror(req
, ERRDOS
, ERRbadfunc
);
4240 case SMB_INFO_QUERY_EAS_FROM_LIST
:
4242 size_t total_ea_len
= 0;
4243 struct ea_list
*ea_file_list
= NULL
;
4245 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
4247 ea_file_list
= get_ea_list_from_file(ctx
, conn
, fsp
, fname
, &total_ea_len
);
4248 ea_list
= ea_list_union(ea_list
, ea_file_list
, &total_ea_len
);
4250 if (!ea_list
|| (total_ea_len
> data_size
)) {
4252 SIVAL(pdata
,0,4); /* EA List Length must be set to 4 if no EA's. */
4256 data_size
= fill_ea_buffer(ctx
, pdata
, data_size
, conn
, ea_list
);
4260 case SMB_INFO_QUERY_ALL_EAS
:
4262 /* We have data_size bytes to put EA's into. */
4263 size_t total_ea_len
= 0;
4265 DEBUG(10,("call_trans2qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
4267 ea_list
= get_ea_list_from_file(ctx
, conn
, fsp
, fname
, &total_ea_len
);
4268 if (!ea_list
|| (total_ea_len
> data_size
)) {
4270 SIVAL(pdata
,0,4); /* EA List Length must be set to 4 if no EA's. */
4274 data_size
= fill_ea_buffer(ctx
, pdata
, data_size
, conn
, ea_list
);
4278 case SMB_FILE_BASIC_INFORMATION
:
4279 case SMB_QUERY_FILE_BASIC_INFO
:
4281 if (info_level
== SMB_QUERY_FILE_BASIC_INFO
) {
4282 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
4283 data_size
= 36; /* w95 returns 40 bytes not 36 - why ?. */
4285 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
4289 put_long_date_timespec(pdata
,create_time_ts
);
4290 put_long_date_timespec(pdata
+8,atime_ts
);
4291 put_long_date_timespec(pdata
+16,mtime_ts
); /* write time */
4292 put_long_date_timespec(pdata
+24,mtime_ts
); /* change time */
4293 SIVAL(pdata
,32,mode
);
4295 DEBUG(5,("SMB_QFBI - "));
4296 DEBUG(5,("create: %s ", ctime(&create_time
)));
4297 DEBUG(5,("access: %s ", ctime(&atime
)));
4298 DEBUG(5,("write: %s ", ctime(&mtime
)));
4299 DEBUG(5,("change: %s ", ctime(&mtime
)));
4300 DEBUG(5,("mode: %x\n", mode
));
4303 case SMB_FILE_STANDARD_INFORMATION
:
4304 case SMB_QUERY_FILE_STANDARD_INFO
:
4306 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
4308 SOFF_T(pdata
,0,allocation_size
);
4309 SOFF_T(pdata
,8,file_size
);
4310 SIVAL(pdata
,16,nlink
);
4311 SCVAL(pdata
,20,delete_pending
?1:0);
4312 SCVAL(pdata
,21,(mode
&aDIR
)?1:0);
4313 SSVAL(pdata
,22,0); /* Padding. */
4316 case SMB_FILE_EA_INFORMATION
:
4317 case SMB_QUERY_FILE_EA_INFO
:
4319 unsigned int ea_size
= estimate_ea_size(conn
, fsp
, fname
);
4320 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
4322 SIVAL(pdata
,0,ea_size
);
4326 /* Get the 8.3 name - used if NT SMB was negotiated. */
4327 case SMB_QUERY_FILE_ALT_NAME_INFO
:
4328 case SMB_FILE_ALTERNATE_NAME_INFORMATION
:
4330 char mangled_name
[13];
4331 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
4332 if (!name_to_8_3(base_name
,mangled_name
,
4333 True
,conn
->params
)) {
4336 NT_STATUS_NO_MEMORY
);
4338 len
= srvstr_push(dstart
, req
->flags2
,
4339 pdata
+4, mangled_name
,
4340 PTR_DIFF(dend
, pdata
+4),
4342 data_size
= 4 + len
;
4347 case SMB_QUERY_FILE_NAME_INFO
:
4349 this must be *exactly* right for ACLs on mapped drives to work
4351 len
= srvstr_push(dstart
, req
->flags2
,
4353 PTR_DIFF(dend
, pdata
+4),
4355 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
4356 data_size
= 4 + len
;
4360 case SMB_FILE_ALLOCATION_INFORMATION
:
4361 case SMB_QUERY_FILE_ALLOCATION_INFO
:
4362 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
4364 SOFF_T(pdata
,0,allocation_size
);
4367 case SMB_FILE_END_OF_FILE_INFORMATION
:
4368 case SMB_QUERY_FILE_END_OF_FILEINFO
:
4369 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
4371 SOFF_T(pdata
,0,file_size
);
4374 case SMB_QUERY_FILE_ALL_INFO
:
4375 case SMB_FILE_ALL_INFORMATION
:
4377 unsigned int ea_size
= estimate_ea_size(conn
, fsp
, fname
);
4378 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
4379 put_long_date_timespec(pdata
,create_time_ts
);
4380 put_long_date_timespec(pdata
+8,atime_ts
);
4381 put_long_date_timespec(pdata
+16,mtime_ts
); /* write time */
4382 put_long_date_timespec(pdata
+24,mtime_ts
); /* change time */
4383 SIVAL(pdata
,32,mode
);
4384 SIVAL(pdata
,36,0); /* padding. */
4386 SOFF_T(pdata
,0,allocation_size
);
4387 SOFF_T(pdata
,8,file_size
);
4388 SIVAL(pdata
,16,nlink
);
4389 SCVAL(pdata
,20,delete_pending
);
4390 SCVAL(pdata
,21,(mode
&aDIR
)?1:0);
4393 SIVAL(pdata
,0,ea_size
);
4394 pdata
+= 4; /* EA info */
4395 len
= srvstr_push(dstart
, req
->flags2
,
4397 PTR_DIFF(dend
, pdata
+4),
4401 data_size
= PTR_DIFF(pdata
,(*ppdata
));
4404 case SMB_FILE_INTERNAL_INFORMATION
:
4405 /* This should be an index number - looks like
4408 I think this causes us to fail the IFSKIT
4409 BasicFileInformationTest. -tpot */
4411 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
4412 SIVAL(pdata
,0,sbuf
.st_ino
); /* FileIndexLow */
4413 SIVAL(pdata
,4,sbuf
.st_dev
); /* FileIndexHigh */
4417 case SMB_FILE_ACCESS_INFORMATION
:
4418 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
4419 SIVAL(pdata
,0,access_mask
);
4423 case SMB_FILE_NAME_INFORMATION
:
4424 /* Pathname with leading '\'. */
4427 byte_len
= dos_PutUniCode(pdata
+4,dos_fname
,(size_t)max_data_bytes
,False
);
4428 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
4429 SIVAL(pdata
,0,byte_len
);
4430 data_size
= 4 + byte_len
;
4434 case SMB_FILE_DISPOSITION_INFORMATION
:
4435 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
4437 SCVAL(pdata
,0,delete_pending
);
4440 case SMB_FILE_POSITION_INFORMATION
:
4441 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
4443 SOFF_T(pdata
,0,pos
);
4446 case SMB_FILE_MODE_INFORMATION
:
4447 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
4448 SIVAL(pdata
,0,mode
);
4452 case SMB_FILE_ALIGNMENT_INFORMATION
:
4453 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
4454 SIVAL(pdata
,0,0); /* No alignment needed. */
4459 * NT4 server just returns "invalid query" to this - if we try
4460 * to answer it then NTws gets a BSOD! (tridge). W2K seems to
4463 /* The first statement above is false - verified using Thursby
4464 * client against NT4 -- gcolley.
4466 case SMB_QUERY_FILE_STREAM_INFO
:
4467 case SMB_FILE_STREAM_INFORMATION
: {
4468 unsigned int num_streams
;
4469 struct stream_struct
*streams
;
4472 DEBUG(10,("call_trans2qfilepathinfo: "
4473 "SMB_FILE_STREAM_INFORMATION\n"));
4475 status
= SMB_VFS_STREAMINFO(
4476 conn
, fsp
, fname
, talloc_tos(),
4477 &num_streams
, &streams
);
4479 if (!NT_STATUS_IS_OK(status
)) {
4480 DEBUG(10, ("could not get stream info: %s\n",
4481 nt_errstr(status
)));
4482 reply_nterror(req
, status
);
4486 status
= marshall_stream_info(num_streams
, streams
,
4487 pdata
, max_data_bytes
,
4490 if (!NT_STATUS_IS_OK(status
)) {
4491 DEBUG(10, ("marshall_stream_info failed: %s\n",
4492 nt_errstr(status
)));
4493 reply_nterror(req
, status
);
4497 TALLOC_FREE(streams
);
4501 case SMB_QUERY_COMPRESSION_INFO
:
4502 case SMB_FILE_COMPRESSION_INFORMATION
:
4503 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
4504 SOFF_T(pdata
,0,file_size
);
4505 SIVAL(pdata
,8,0); /* ??? */
4506 SIVAL(pdata
,12,0); /* ??? */
4510 case SMB_FILE_NETWORK_OPEN_INFORMATION
:
4511 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
4512 put_long_date_timespec(pdata
,create_time_ts
);
4513 put_long_date_timespec(pdata
+8,atime_ts
);
4514 put_long_date_timespec(pdata
+16,mtime_ts
); /* write time */
4515 put_long_date_timespec(pdata
+24,mtime_ts
); /* change time */
4516 SOFF_T(pdata
,32,allocation_size
);
4517 SOFF_T(pdata
,40,file_size
);
4518 SIVAL(pdata
,48,mode
);
4519 SIVAL(pdata
,52,0); /* ??? */
4523 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION
:
4524 DEBUG(10,("call_trans2qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
4525 SIVAL(pdata
,0,mode
);
4531 * CIFS UNIX Extensions.
4534 case SMB_QUERY_FILE_UNIX_BASIC
:
4536 pdata
= store_file_unix_basic(conn
, pdata
, fsp
, &sbuf
);
4537 data_size
= PTR_DIFF(pdata
,(*ppdata
));
4541 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC "));
4543 for (i
=0; i
<100; i
++)
4544 DEBUG(4,("%d=%x, ",i
, (*ppdata
)[i
]));
4550 case SMB_QUERY_FILE_UNIX_INFO2
:
4552 pdata
= store_file_unix_basic_info2(conn
, pdata
, fsp
, &sbuf
);
4553 data_size
= PTR_DIFF(pdata
,(*ppdata
));
4557 DEBUG(4,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
4559 for (i
=0; i
<100; i
++)
4560 DEBUG(4,("%d=%x, ",i
, (*ppdata
)[i
]));
4566 case SMB_QUERY_FILE_UNIX_LINK
:
4568 char *buffer
= TALLOC_ARRAY(ctx
, char, PATH_MAX
+1);
4571 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
4575 DEBUG(10,("call_trans2qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
4577 if(!S_ISLNK(sbuf
.st_mode
)) {
4578 reply_unixerror(req
, ERRSRV
,
4583 reply_unixerror(req
, ERRDOS
, ERRbadlink
);
4586 len
= SMB_VFS_READLINK(conn
,fullpathname
,
4589 reply_unixerror(req
, ERRDOS
,
4594 len
= srvstr_push(dstart
, req
->flags2
,
4596 PTR_DIFF(dend
, pdata
),
4599 data_size
= PTR_DIFF(pdata
,(*ppdata
));
4604 #if defined(HAVE_POSIX_ACLS)
4605 case SMB_QUERY_POSIX_ACL
:
4607 SMB_ACL_T file_acl
= NULL
;
4608 SMB_ACL_T def_acl
= NULL
;
4609 uint16 num_file_acls
= 0;
4610 uint16 num_def_acls
= 0;
4612 if (fsp
&& !fsp
->is_directory
&& (fsp
->fh
->fd
!= -1)) {
4613 file_acl
= SMB_VFS_SYS_ACL_GET_FD(fsp
);
4615 file_acl
= SMB_VFS_SYS_ACL_GET_FILE(conn
, fname
, SMB_ACL_TYPE_ACCESS
);
4618 if (file_acl
== NULL
&& no_acl_syscall_error(errno
)) {
4619 DEBUG(5,("call_trans2qfilepathinfo: ACLs not implemented on filesystem containing %s\n",
4623 NT_STATUS_NOT_IMPLEMENTED
);
4627 if (S_ISDIR(sbuf
.st_mode
)) {
4628 if (fsp
&& fsp
->is_directory
) {
4629 def_acl
= SMB_VFS_SYS_ACL_GET_FILE(conn
, fsp
->fsp_name
, SMB_ACL_TYPE_DEFAULT
);
4631 def_acl
= SMB_VFS_SYS_ACL_GET_FILE(conn
, fname
, SMB_ACL_TYPE_DEFAULT
);
4633 def_acl
= free_empty_sys_acl(conn
, def_acl
);
4636 num_file_acls
= count_acl_entries(conn
, file_acl
);
4637 num_def_acls
= count_acl_entries(conn
, def_acl
);
4639 if ( data_size
< (num_file_acls
+ num_def_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
+ SMB_POSIX_ACL_HEADER_SIZE
) {
4640 DEBUG(5,("call_trans2qfilepathinfo: data_size too small (%u) need %u\n",
4642 (unsigned int)((num_file_acls
+ num_def_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
+
4643 SMB_POSIX_ACL_HEADER_SIZE
) ));
4645 SMB_VFS_SYS_ACL_FREE_ACL(conn
, file_acl
);
4648 SMB_VFS_SYS_ACL_FREE_ACL(conn
, def_acl
);
4652 NT_STATUS_BUFFER_TOO_SMALL
);
4656 SSVAL(pdata
,0,SMB_POSIX_ACL_VERSION
);
4657 SSVAL(pdata
,2,num_file_acls
);
4658 SSVAL(pdata
,4,num_def_acls
);
4659 if (!marshall_posix_acl(conn
, pdata
+ SMB_POSIX_ACL_HEADER_SIZE
, &sbuf
, file_acl
)) {
4661 SMB_VFS_SYS_ACL_FREE_ACL(conn
, file_acl
);
4664 SMB_VFS_SYS_ACL_FREE_ACL(conn
, def_acl
);
4667 req
, NT_STATUS_INTERNAL_ERROR
);
4670 if (!marshall_posix_acl(conn
, pdata
+ SMB_POSIX_ACL_HEADER_SIZE
+ (num_file_acls
*SMB_POSIX_ACL_ENTRY_SIZE
), &sbuf
, def_acl
)) {
4672 SMB_VFS_SYS_ACL_FREE_ACL(conn
, file_acl
);
4675 SMB_VFS_SYS_ACL_FREE_ACL(conn
, def_acl
);
4679 NT_STATUS_INTERNAL_ERROR
);
4684 SMB_VFS_SYS_ACL_FREE_ACL(conn
, file_acl
);
4687 SMB_VFS_SYS_ACL_FREE_ACL(conn
, def_acl
);
4689 data_size
= (num_file_acls
+ num_def_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
+ SMB_POSIX_ACL_HEADER_SIZE
;
4695 case SMB_QUERY_POSIX_LOCK
:
4697 NTSTATUS status
= NT_STATUS_INVALID_LEVEL
;
4699 SMB_BIG_UINT offset
;
4701 enum brl_type lock_type
;
4703 if (total_data
!= POSIX_LOCK_DATA_SIZE
) {
4705 req
, NT_STATUS_INVALID_PARAMETER
);
4709 switch (SVAL(pdata
, POSIX_LOCK_TYPE_OFFSET
)) {
4710 case POSIX_LOCK_TYPE_READ
:
4711 lock_type
= READ_LOCK
;
4713 case POSIX_LOCK_TYPE_WRITE
:
4714 lock_type
= WRITE_LOCK
;
4716 case POSIX_LOCK_TYPE_UNLOCK
:
4718 /* There's no point in asking for an unlock... */
4721 NT_STATUS_INVALID_PARAMETER
);
4725 lock_pid
= IVAL(pdata
, POSIX_LOCK_PID_OFFSET
);
4726 #if defined(HAVE_LONGLONG)
4727 offset
= (((SMB_BIG_UINT
) IVAL(pdata
,(POSIX_LOCK_START_OFFSET
+4))) << 32) |
4728 ((SMB_BIG_UINT
) IVAL(pdata
,POSIX_LOCK_START_OFFSET
));
4729 count
= (((SMB_BIG_UINT
) IVAL(pdata
,(POSIX_LOCK_LEN_OFFSET
+4))) << 32) |
4730 ((SMB_BIG_UINT
) IVAL(pdata
,POSIX_LOCK_LEN_OFFSET
));
4731 #else /* HAVE_LONGLONG */
4732 offset
= (SMB_BIG_UINT
)IVAL(pdata
,POSIX_LOCK_START_OFFSET
);
4733 count
= (SMB_BIG_UINT
)IVAL(pdata
,POSIX_LOCK_LEN_OFFSET
);
4734 #endif /* HAVE_LONGLONG */
4736 status
= query_lock(fsp
,
4743 if (ERROR_WAS_LOCK_DENIED(status
)) {
4744 /* Here we need to report who has it locked... */
4745 data_size
= POSIX_LOCK_DATA_SIZE
;
4747 SSVAL(pdata
, POSIX_LOCK_TYPE_OFFSET
, lock_type
);
4748 SSVAL(pdata
, POSIX_LOCK_FLAGS_OFFSET
, 0);
4749 SIVAL(pdata
, POSIX_LOCK_PID_OFFSET
, lock_pid
);
4750 #if defined(HAVE_LONGLONG)
4751 SIVAL(pdata
, POSIX_LOCK_START_OFFSET
, (uint32
)(offset
& 0xFFFFFFFF));
4752 SIVAL(pdata
, POSIX_LOCK_START_OFFSET
+ 4, (uint32
)((offset
>> 32) & 0xFFFFFFFF));
4753 SIVAL(pdata
, POSIX_LOCK_LEN_OFFSET
, (uint32
)(count
& 0xFFFFFFFF));
4754 SIVAL(pdata
, POSIX_LOCK_LEN_OFFSET
+ 4, (uint32
)((count
>> 32) & 0xFFFFFFFF));
4755 #else /* HAVE_LONGLONG */
4756 SIVAL(pdata
, POSIX_LOCK_START_OFFSET
, offset
);
4757 SIVAL(pdata
, POSIX_LOCK_LEN_OFFSET
, count
);
4758 #endif /* HAVE_LONGLONG */
4760 } else if (NT_STATUS_IS_OK(status
)) {
4761 /* For success we just return a copy of what we sent
4762 with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
4763 data_size
= POSIX_LOCK_DATA_SIZE
;
4764 memcpy(pdata
, lock_data
, POSIX_LOCK_DATA_SIZE
);
4765 SSVAL(pdata
, POSIX_LOCK_TYPE_OFFSET
, POSIX_LOCK_TYPE_UNLOCK
);
4767 reply_nterror(req
, status
);
4774 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
4778 send_trans2_replies(conn
, req
, params
, param_size
, *ppdata
, data_size
,
4784 /****************************************************************************
4785 Set a hard link (called by UNIX extensions and by NT rename with HARD link
4787 ****************************************************************************/
4789 NTSTATUS
hardlink_internals(TALLOC_CTX
*ctx
,
4790 connection_struct
*conn
,
4791 const char *oldname_in
,
4792 const char *newname_in
)
4794 SMB_STRUCT_STAT sbuf1
, sbuf2
;
4795 char *last_component_oldname
= NULL
;
4796 char *last_component_newname
= NULL
;
4797 char *oldname
= NULL
;
4798 char *newname
= NULL
;
4799 NTSTATUS status
= NT_STATUS_OK
;
4804 status
= unix_convert(ctx
, conn
, oldname_in
, False
, &oldname
,
4805 &last_component_oldname
, &sbuf1
);
4806 if (!NT_STATUS_IS_OK(status
)) {
4810 status
= check_name(conn
, oldname
);
4811 if (!NT_STATUS_IS_OK(status
)) {
4815 /* source must already exist. */
4816 if (!VALID_STAT(sbuf1
)) {
4817 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
4820 status
= unix_convert(ctx
, conn
, newname_in
, False
, &newname
,
4821 &last_component_newname
, &sbuf2
);
4822 if (!NT_STATUS_IS_OK(status
)) {
4826 status
= check_name(conn
, newname
);
4827 if (!NT_STATUS_IS_OK(status
)) {
4831 /* Disallow if newname already exists. */
4832 if (VALID_STAT(sbuf2
)) {
4833 return NT_STATUS_OBJECT_NAME_COLLISION
;
4836 /* No links from a directory. */
4837 if (S_ISDIR(sbuf1
.st_mode
)) {
4838 return NT_STATUS_FILE_IS_A_DIRECTORY
;
4841 /* Ensure this is within the share. */
4842 status
= check_reduced_name(conn
, oldname
);
4843 if (!NT_STATUS_IS_OK(status
)) {
4847 DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n", newname
, oldname
));
4849 if (SMB_VFS_LINK(conn
,oldname
,newname
) != 0) {
4850 status
= map_nt_error_from_unix(errno
);
4851 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
4852 nt_errstr(status
), newname
, oldname
));
4858 /****************************************************************************
4859 Deal with setting the time from any of the setfilepathinfo functions.
4860 ****************************************************************************/
4862 NTSTATUS
smb_set_file_time(connection_struct
*conn
,
4865 const SMB_STRUCT_STAT
*psbuf
,
4866 struct timespec ts
[2],
4867 bool setting_write_time
)
4870 FILE_NOTIFY_CHANGE_LAST_ACCESS
4871 |FILE_NOTIFY_CHANGE_LAST_WRITE
;
4873 if (!VALID_STAT(*psbuf
)) {
4874 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
4877 /* get some defaults (no modifications) if any info is zero or -1. */
4878 if (null_timespec(ts
[0])) {
4879 ts
[0] = get_atimespec(psbuf
);
4880 action
&= ~FILE_NOTIFY_CHANGE_LAST_ACCESS
;
4883 if (null_timespec(ts
[1])) {
4884 ts
[1] = get_mtimespec(psbuf
);
4885 action
&= ~FILE_NOTIFY_CHANGE_LAST_WRITE
;
4888 if (!setting_write_time
) {
4889 /* ts[1] comes from change time, not write time. */
4890 action
&= ~FILE_NOTIFY_CHANGE_LAST_WRITE
;
4893 DEBUG(6,("smb_set_file_time: actime: %s " , time_to_asc(convert_timespec_to_time_t(ts
[0])) ));
4894 DEBUG(6,("smb_set_file_time: modtime: %s ", time_to_asc(convert_timespec_to_time_t(ts
[1])) ));
4897 * Try and set the times of this file if
4898 * they are different from the current values.
4902 struct timespec mts
= get_mtimespec(psbuf
);
4903 struct timespec ats
= get_atimespec(psbuf
);
4904 if ((timespec_compare(&ts
[0], &ats
) == 0) && (timespec_compare(&ts
[1], &mts
) == 0)) {
4905 return NT_STATUS_OK
;
4909 if (setting_write_time
) {
4911 * This was a setfileinfo on an open file.
4912 * NT does this a lot. We also need to
4913 * set the time here, as it can be read by
4914 * FindFirst/FindNext and with the patch for bug #2045
4915 * in smbd/fileio.c it ensures that this timestamp is
4916 * kept sticky even after a write. We save the request
4917 * away and will set it on file close and after a write. JRA.
4920 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
4921 time_to_asc(convert_timespec_to_time_t(ts
[1])) ));
4924 if (fsp
->base_fsp
) {
4925 set_sticky_write_time_fsp(fsp
->base_fsp
, ts
[1]);
4927 set_sticky_write_time_fsp(fsp
, ts
[1]);
4930 set_sticky_write_time_path(conn
, fname
,
4931 vfs_file_id_from_sbuf(conn
, psbuf
),
4936 DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
4938 if (fsp
&& fsp
->base_fsp
) {
4939 fname
= fsp
->base_fsp
->fsp_name
;
4942 if(file_ntimes(conn
, fname
, ts
)!=0) {
4943 return map_nt_error_from_unix(errno
);
4945 notify_fname(conn
, NOTIFY_ACTION_MODIFIED
, action
, fname
);
4947 return NT_STATUS_OK
;
4950 /****************************************************************************
4951 Deal with setting the dosmode from any of the setfilepathinfo functions.
4952 ****************************************************************************/
4954 static NTSTATUS
smb_set_file_dosmode(connection_struct
*conn
,
4956 SMB_STRUCT_STAT
*psbuf
,
4959 if (!VALID_STAT(*psbuf
)) {
4960 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
4964 if (S_ISDIR(psbuf
->st_mode
)) {
4971 DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode
));
4973 /* check the mode isn't different, before changing it */
4974 if ((dosmode
!= 0) && (dosmode
!= dos_mode(conn
, fname
, psbuf
))) {
4976 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode 0x%x\n",
4977 fname
, (unsigned int)dosmode
));
4979 if(file_set_dosmode(conn
, fname
, dosmode
, psbuf
, NULL
, false)) {
4980 DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of %s failed (%s)\n",
4981 fname
, strerror(errno
)));
4982 return map_nt_error_from_unix(errno
);
4985 return NT_STATUS_OK
;
4988 /****************************************************************************
4989 Deal with setting the size from any of the setfilepathinfo functions.
4990 ****************************************************************************/
4992 static NTSTATUS
smb_set_file_size(connection_struct
*conn
,
4993 struct smb_request
*req
,
4996 SMB_STRUCT_STAT
*psbuf
,
4999 NTSTATUS status
= NT_STATUS_OK
;
5000 files_struct
*new_fsp
= NULL
;
5002 if (!VALID_STAT(*psbuf
)) {
5003 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
5006 DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size
));
5008 if (size
== get_file_size(*psbuf
)) {
5009 return NT_STATUS_OK
;
5012 DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
5013 fname
, (double)size
));
5015 if (fsp
&& fsp
->fh
->fd
!= -1) {
5016 /* Handle based call. */
5017 if (vfs_set_filelen(fsp
, size
) == -1) {
5018 return map_nt_error_from_unix(errno
);
5020 trigger_write_time_update_immediate(fsp
);
5021 return NT_STATUS_OK
;
5024 status
= open_file_ntcreate(conn
, req
, fname
, psbuf
,
5025 FILE_WRITE_ATTRIBUTES
,
5026 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
5029 FILE_ATTRIBUTE_NORMAL
,
5030 FORCE_OPLOCK_BREAK_TO_NONE
,
5033 if (!NT_STATUS_IS_OK(status
)) {
5034 /* NB. We check for open_was_deferred in the caller. */
5038 if (vfs_set_filelen(new_fsp
, size
) == -1) {
5039 status
= map_nt_error_from_unix(errno
);
5040 close_file(new_fsp
,NORMAL_CLOSE
);
5044 trigger_write_time_update_immediate(new_fsp
);
5045 close_file(new_fsp
,NORMAL_CLOSE
);
5046 return NT_STATUS_OK
;
5049 /****************************************************************************
5050 Deal with SMB_INFO_SET_EA.
5051 ****************************************************************************/
5053 static NTSTATUS
smb_info_set_ea(connection_struct
*conn
,
5059 struct ea_list
*ea_list
= NULL
;
5060 TALLOC_CTX
*ctx
= NULL
;
5061 NTSTATUS status
= NT_STATUS_OK
;
5063 if (total_data
< 10) {
5065 /* OS/2 workplace shell seems to send SET_EA requests of "null"
5066 length. They seem to have no effect. Bug #3212. JRA */
5068 if ((total_data
== 4) && (IVAL(pdata
,0) == 4)) {
5069 /* We're done. We only get EA info in this call. */
5070 return NT_STATUS_OK
;
5073 return NT_STATUS_INVALID_PARAMETER
;
5076 if (IVAL(pdata
,0) > total_data
) {
5077 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
5078 IVAL(pdata
,0), (unsigned int)total_data
));
5079 return NT_STATUS_INVALID_PARAMETER
;
5083 ea_list
= read_ea_list(ctx
, pdata
+ 4, total_data
- 4);
5085 return NT_STATUS_INVALID_PARAMETER
;
5087 status
= set_ea(conn
, fsp
, fname
, ea_list
);
5092 /****************************************************************************
5093 Deal with SMB_SET_FILE_DISPOSITION_INFO.
5094 ****************************************************************************/
5096 static NTSTATUS
smb_set_file_disposition_info(connection_struct
*conn
,
5101 SMB_STRUCT_STAT
*psbuf
)
5103 NTSTATUS status
= NT_STATUS_OK
;
5104 bool delete_on_close
;
5107 if (total_data
< 1) {
5108 return NT_STATUS_INVALID_PARAMETER
;
5112 return NT_STATUS_INVALID_HANDLE
;
5115 delete_on_close
= (CVAL(pdata
,0) ? True
: False
);
5116 dosmode
= dos_mode(conn
, fname
, psbuf
);
5118 DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
5119 "delete_on_close = %u\n",
5121 (unsigned int)dosmode
,
5122 (unsigned int)delete_on_close
));
5124 status
= can_set_delete_on_close(fsp
, delete_on_close
, dosmode
);
5126 if (!NT_STATUS_IS_OK(status
)) {
5130 /* The set is across all open files on this dev/inode pair. */
5131 if (!set_delete_on_close(fsp
, delete_on_close
, ¤t_user
.ut
)) {
5132 return NT_STATUS_ACCESS_DENIED
;
5134 return NT_STATUS_OK
;
5137 /****************************************************************************
5138 Deal with SMB_FILE_POSITION_INFORMATION.
5139 ****************************************************************************/
5141 static NTSTATUS
smb_file_position_information(connection_struct
*conn
,
5146 SMB_BIG_UINT position_information
;
5148 if (total_data
< 8) {
5149 return NT_STATUS_INVALID_PARAMETER
;
5153 /* Ignore on pathname based set. */
5154 return NT_STATUS_OK
;
5157 position_information
= (SMB_BIG_UINT
)IVAL(pdata
,0);
5158 #ifdef LARGE_SMB_OFF_T
5159 position_information
|= (((SMB_BIG_UINT
)IVAL(pdata
,4)) << 32);
5160 #else /* LARGE_SMB_OFF_T */
5161 if (IVAL(pdata
,4) != 0) {
5162 /* more than 32 bits? */
5163 return NT_STATUS_INVALID_PARAMETER
;
5165 #endif /* LARGE_SMB_OFF_T */
5167 DEBUG(10,("smb_file_position_information: Set file position information for file %s to %.0f\n",
5168 fsp
->fsp_name
, (double)position_information
));
5169 fsp
->fh
->position_information
= position_information
;
5170 return NT_STATUS_OK
;
5173 /****************************************************************************
5174 Deal with SMB_FILE_MODE_INFORMATION.
5175 ****************************************************************************/
5177 static NTSTATUS
smb_file_mode_information(connection_struct
*conn
,
5183 if (total_data
< 4) {
5184 return NT_STATUS_INVALID_PARAMETER
;
5186 mode
= IVAL(pdata
,0);
5187 if (mode
!= 0 && mode
!= 2 && mode
!= 4 && mode
!= 6) {
5188 return NT_STATUS_INVALID_PARAMETER
;
5190 return NT_STATUS_OK
;
5193 /****************************************************************************
5194 Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
5195 ****************************************************************************/
5197 static NTSTATUS
smb_set_file_unix_link(connection_struct
*conn
,
5198 struct smb_request
*req
,
5203 char *link_target
= NULL
;
5204 const char *newname
= fname
;
5205 NTSTATUS status
= NT_STATUS_OK
;
5206 TALLOC_CTX
*ctx
= talloc_tos();
5208 /* Set a symbolic link. */
5209 /* Don't allow this if follow links is false. */
5211 if (total_data
== 0) {
5212 return NT_STATUS_INVALID_PARAMETER
;
5215 if (!lp_symlinks(SNUM(conn
))) {
5216 return NT_STATUS_ACCESS_DENIED
;
5219 srvstr_pull_talloc(ctx
, pdata
, req
->flags2
, &link_target
, pdata
,
5220 total_data
, STR_TERMINATE
);
5223 return NT_STATUS_INVALID_PARAMETER
;
5226 /* !widelinks forces the target path to be within the share. */
5227 /* This means we can interpret the target as a pathname. */
5228 if (!lp_widelinks(SNUM(conn
))) {
5229 char *rel_name
= NULL
;
5230 char *last_dirp
= NULL
;
5232 if (*link_target
== '/') {
5233 /* No absolute paths allowed. */
5234 return NT_STATUS_ACCESS_DENIED
;
5236 rel_name
= talloc_strdup(ctx
,newname
);
5238 return NT_STATUS_NO_MEMORY
;
5240 last_dirp
= strrchr_m(rel_name
, '/');
5242 last_dirp
[1] = '\0';
5244 rel_name
= talloc_strdup(ctx
,"./");
5246 return NT_STATUS_NO_MEMORY
;
5249 rel_name
= talloc_asprintf_append(rel_name
,
5253 return NT_STATUS_NO_MEMORY
;
5256 status
= check_name(conn
, rel_name
);
5257 if (!NT_STATUS_IS_OK(status
)) {
5262 DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
5263 newname
, link_target
));
5265 if (SMB_VFS_SYMLINK(conn
,link_target
,newname
) != 0) {
5266 return map_nt_error_from_unix(errno
);
5269 return NT_STATUS_OK
;
5272 /****************************************************************************
5273 Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
5274 ****************************************************************************/
5276 static NTSTATUS
smb_set_file_unix_hlink(connection_struct
*conn
,
5277 struct smb_request
*req
,
5278 const char *pdata
, int total_data
,
5281 char *oldname
= NULL
;
5282 TALLOC_CTX
*ctx
= talloc_tos();
5283 NTSTATUS status
= NT_STATUS_OK
;
5285 /* Set a hard link. */
5286 if (total_data
== 0) {
5287 return NT_STATUS_INVALID_PARAMETER
;
5290 srvstr_get_path(ctx
, pdata
, req
->flags2
, &oldname
, pdata
,
5291 total_data
, STR_TERMINATE
, &status
);
5292 if (!NT_STATUS_IS_OK(status
)) {
5296 status
= resolve_dfspath(ctx
, conn
,
5297 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
5300 if (!NT_STATUS_IS_OK(status
)) {
5304 DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
5307 return hardlink_internals(ctx
, conn
, oldname
, fname
);
5310 /****************************************************************************
5311 Deal with SMB_FILE_RENAME_INFORMATION.
5312 ****************************************************************************/
5314 static NTSTATUS
smb_file_rename_information(connection_struct
*conn
,
5315 struct smb_request
*req
,
5324 char *newname
= NULL
;
5325 char *base_name
= NULL
;
5326 bool dest_has_wcard
= False
;
5327 SMB_STRUCT_STAT sbuf
;
5328 char *newname_last_component
= NULL
;
5329 NTSTATUS status
= NT_STATUS_OK
;
5331 TALLOC_CTX
*ctx
= talloc_tos();
5333 if (total_data
< 13) {
5334 return NT_STATUS_INVALID_PARAMETER
;
5339 overwrite
= (CVAL(pdata
,0) ? True
: False
);
5340 root_fid
= IVAL(pdata
,4);
5341 len
= IVAL(pdata
,8);
5343 if (len
> (total_data
- 12) || (len
== 0) || (root_fid
!= 0)) {
5344 return NT_STATUS_INVALID_PARAMETER
;
5347 srvstr_get_path_wcard(ctx
, pdata
, req
->flags2
, &newname
, &pdata
[12],
5350 if (!NT_STATUS_IS_OK(status
)) {
5354 DEBUG(10,("smb_file_rename_information: got name |%s|\n",
5357 status
= resolve_dfspath_wcard(ctx
, conn
,
5358 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
5362 if (!NT_STATUS_IS_OK(status
)) {
5366 /* Check the new name has no '/' characters. */
5367 if (strchr_m(newname
, '/')) {
5368 return NT_STATUS_NOT_SUPPORTED
;
5371 if (fsp
&& fsp
->base_fsp
) {
5372 /* newname must be a stream name. */
5373 if (newname
[0] != ':') {
5374 return NT_STATUS_NOT_SUPPORTED
;
5376 base_name
= talloc_asprintf(ctx
, "%s%s",
5377 fsp
->base_fsp
->fsp_name
,
5380 return NT_STATUS_NO_MEMORY
;
5383 /* newname must *not* be a stream name. */
5384 if (is_ntfs_stream_name(newname
)) {
5385 return NT_STATUS_NOT_SUPPORTED
;
5388 /* Create the base directory. */
5389 base_name
= talloc_strdup(ctx
, fname
);
5391 return NT_STATUS_NO_MEMORY
;
5393 p
= strrchr_m(base_name
, '/');
5397 base_name
= talloc_strdup(ctx
, "./");
5399 return NT_STATUS_NO_MEMORY
;
5402 /* Append the new name. */
5403 base_name
= talloc_asprintf_append(base_name
,
5407 return NT_STATUS_NO_MEMORY
;
5410 status
= unix_convert(ctx
, conn
, newname
, False
,
5412 &newname_last_component
,
5415 /* If an error we expect this to be
5416 * NT_STATUS_OBJECT_PATH_NOT_FOUND */
5418 if (!NT_STATUS_IS_OK(status
)
5419 && !NT_STATUS_EQUAL(NT_STATUS_OBJECT_PATH_NOT_FOUND
,
5426 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
5427 fsp
->fnum
, fsp
->fsp_name
, base_name
));
5428 status
= rename_internals_fsp(conn
, fsp
, base_name
,
5429 newname_last_component
, 0,
5432 DEBUG(10,("smb_file_rename_information: SMB_FILE_RENAME_INFORMATION %s -> %s\n",
5433 fname
, base_name
));
5434 status
= rename_internals(ctx
, conn
, req
, fname
, base_name
, 0,
5435 overwrite
, False
, dest_has_wcard
,
5436 FILE_WRITE_ATTRIBUTES
);
5442 /****************************************************************************
5443 Deal with SMB_SET_POSIX_ACL.
5444 ****************************************************************************/
5446 #if defined(HAVE_POSIX_ACLS)
5447 static NTSTATUS
smb_set_posix_acl(connection_struct
*conn
,
5452 SMB_STRUCT_STAT
*psbuf
)
5454 uint16 posix_acl_version
;
5455 uint16 num_file_acls
;
5456 uint16 num_def_acls
;
5457 bool valid_file_acls
= True
;
5458 bool valid_def_acls
= True
;
5460 if (total_data
< SMB_POSIX_ACL_HEADER_SIZE
) {
5461 return NT_STATUS_INVALID_PARAMETER
;
5463 posix_acl_version
= SVAL(pdata
,0);
5464 num_file_acls
= SVAL(pdata
,2);
5465 num_def_acls
= SVAL(pdata
,4);
5467 if (num_file_acls
== SMB_POSIX_IGNORE_ACE_ENTRIES
) {
5468 valid_file_acls
= False
;
5472 if (num_def_acls
== SMB_POSIX_IGNORE_ACE_ENTRIES
) {
5473 valid_def_acls
= False
;
5477 if (posix_acl_version
!= SMB_POSIX_ACL_VERSION
) {
5478 return NT_STATUS_INVALID_PARAMETER
;
5481 if (total_data
< SMB_POSIX_ACL_HEADER_SIZE
+
5482 (num_file_acls
+num_def_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
) {
5483 return NT_STATUS_INVALID_PARAMETER
;
5486 DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
5487 fname
? fname
: fsp
->fsp_name
,
5488 (unsigned int)num_file_acls
,
5489 (unsigned int)num_def_acls
));
5491 if (valid_file_acls
&& !set_unix_posix_acl(conn
, fsp
, fname
, num_file_acls
,
5492 pdata
+ SMB_POSIX_ACL_HEADER_SIZE
)) {
5493 return map_nt_error_from_unix(errno
);
5496 if (valid_def_acls
&& !set_unix_posix_default_acl(conn
, fname
, psbuf
, num_def_acls
,
5497 pdata
+ SMB_POSIX_ACL_HEADER_SIZE
+
5498 (num_file_acls
*SMB_POSIX_ACL_ENTRY_SIZE
))) {
5499 return map_nt_error_from_unix(errno
);
5501 return NT_STATUS_OK
;
5505 /****************************************************************************
5506 Deal with SMB_SET_POSIX_LOCK.
5507 ****************************************************************************/
5509 static NTSTATUS
smb_set_posix_lock(connection_struct
*conn
,
5510 const struct smb_request
*req
,
5516 SMB_BIG_UINT offset
;
5518 bool blocking_lock
= False
;
5519 enum brl_type lock_type
;
5521 NTSTATUS status
= NT_STATUS_OK
;
5523 if (fsp
== NULL
|| fsp
->fh
->fd
== -1) {
5524 return NT_STATUS_INVALID_HANDLE
;
5527 if (total_data
!= POSIX_LOCK_DATA_SIZE
) {
5528 return NT_STATUS_INVALID_PARAMETER
;
5531 switch (SVAL(pdata
, POSIX_LOCK_TYPE_OFFSET
)) {
5532 case POSIX_LOCK_TYPE_READ
:
5533 lock_type
= READ_LOCK
;
5535 case POSIX_LOCK_TYPE_WRITE
:
5536 /* Return the right POSIX-mappable error code for files opened read-only. */
5537 if (!fsp
->can_write
) {
5538 return NT_STATUS_INVALID_HANDLE
;
5540 lock_type
= WRITE_LOCK
;
5542 case POSIX_LOCK_TYPE_UNLOCK
:
5543 lock_type
= UNLOCK_LOCK
;
5546 return NT_STATUS_INVALID_PARAMETER
;
5549 if (SVAL(pdata
,POSIX_LOCK_FLAGS_OFFSET
) == POSIX_LOCK_FLAG_NOWAIT
) {
5550 blocking_lock
= False
;
5551 } else if (SVAL(pdata
,POSIX_LOCK_FLAGS_OFFSET
) == POSIX_LOCK_FLAG_WAIT
) {
5552 blocking_lock
= True
;
5554 return NT_STATUS_INVALID_PARAMETER
;
5557 if (!lp_blocking_locks(SNUM(conn
))) {
5558 blocking_lock
= False
;
5561 lock_pid
= IVAL(pdata
, POSIX_LOCK_PID_OFFSET
);
5562 #if defined(HAVE_LONGLONG)
5563 offset
= (((SMB_BIG_UINT
) IVAL(pdata
,(POSIX_LOCK_START_OFFSET
+4))) << 32) |
5564 ((SMB_BIG_UINT
) IVAL(pdata
,POSIX_LOCK_START_OFFSET
));
5565 count
= (((SMB_BIG_UINT
) IVAL(pdata
,(POSIX_LOCK_LEN_OFFSET
+4))) << 32) |
5566 ((SMB_BIG_UINT
) IVAL(pdata
,POSIX_LOCK_LEN_OFFSET
));
5567 #else /* HAVE_LONGLONG */
5568 offset
= (SMB_BIG_UINT
)IVAL(pdata
,POSIX_LOCK_START_OFFSET
);
5569 count
= (SMB_BIG_UINT
)IVAL(pdata
,POSIX_LOCK_LEN_OFFSET
);
5570 #endif /* HAVE_LONGLONG */
5572 DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
5573 "lock_pid = %u, count = %.0f, offset = %.0f\n",
5575 (unsigned int)lock_type
,
5576 (unsigned int)lock_pid
,
5580 if (lock_type
== UNLOCK_LOCK
) {
5581 status
= do_unlock(smbd_messaging_context(),
5588 uint32 block_smbpid
;
5590 struct byte_range_lock
*br_lck
= do_lock(smbd_messaging_context(),
5601 if (br_lck
&& blocking_lock
&& ERROR_WAS_LOCK_DENIED(status
)) {
5603 * A blocking lock was requested. Package up
5604 * this smb into a queued request and push it
5605 * onto the blocking lock queue.
5607 if(push_blocking_lock_request(br_lck
,
5610 -1, /* infinite timeout. */
5618 TALLOC_FREE(br_lck
);
5622 TALLOC_FREE(br_lck
);
5628 /****************************************************************************
5629 Deal with SMB_INFO_STANDARD.
5630 ****************************************************************************/
5632 static NTSTATUS
smb_set_info_standard(connection_struct
*conn
,
5637 const SMB_STRUCT_STAT
*psbuf
)
5639 struct timespec ts
[2];
5641 if (total_data
< 12) {
5642 return NT_STATUS_INVALID_PARAMETER
;
5646 ts
[0] = convert_time_t_to_timespec(srv_make_unix_date2(pdata
+l1_fdateLastAccess
));
5648 ts
[1] = convert_time_t_to_timespec(srv_make_unix_date2(pdata
+l1_fdateLastWrite
));
5650 DEBUG(10,("smb_set_info_standard: file %s\n",
5651 fname
? fname
: fsp
->fsp_name
));
5653 return smb_set_file_time(conn
,
5661 /****************************************************************************
5662 Deal with SMB_SET_FILE_BASIC_INFO.
5663 ****************************************************************************/
5665 static NTSTATUS
smb_set_file_basic_info(connection_struct
*conn
,
5670 SMB_STRUCT_STAT
*psbuf
)
5672 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
5673 struct timespec write_time
;
5674 struct timespec changed_time
;
5676 struct timespec ts
[2];
5677 NTSTATUS status
= NT_STATUS_OK
;
5678 bool setting_write_time
= true;
5680 if (total_data
< 36) {
5681 return NT_STATUS_INVALID_PARAMETER
;
5684 /* Set the attributes */
5685 dosmode
= IVAL(pdata
,32);
5686 status
= smb_set_file_dosmode(conn
,
5690 if (!NT_STATUS_IS_OK(status
)) {
5694 /* Ignore create time at offset pdata. */
5697 ts
[0] = interpret_long_date(pdata
+8);
5699 write_time
= interpret_long_date(pdata
+16);
5700 changed_time
= interpret_long_date(pdata
+24);
5703 ts
[1] = timespec_min(&write_time
, &changed_time
);
5705 if ((timespec_compare(&write_time
, &ts
[1]) == 1) && !null_timespec(write_time
)) {
5709 /* Prefer a defined time to an undefined one. */
5710 if (null_timespec(ts
[1])) {
5711 if (null_timespec(write_time
)) {
5712 ts
[1] = changed_time
;
5713 setting_write_time
= false;
5719 DEBUG(10,("smb_set_file_basic_info: file %s\n",
5720 fname
? fname
: fsp
->fsp_name
));
5722 return smb_set_file_time(conn
,
5727 setting_write_time
);
5730 /****************************************************************************
5731 Deal with SMB_SET_FILE_ALLOCATION_INFO.
5732 ****************************************************************************/
5734 static NTSTATUS
smb_set_file_allocation_info(connection_struct
*conn
,
5735 struct smb_request
*req
,
5740 SMB_STRUCT_STAT
*psbuf
)
5742 SMB_BIG_UINT allocation_size
= 0;
5743 NTSTATUS status
= NT_STATUS_OK
;
5744 files_struct
*new_fsp
= NULL
;
5746 if (!VALID_STAT(*psbuf
)) {
5747 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
5750 if (total_data
< 8) {
5751 return NT_STATUS_INVALID_PARAMETER
;
5754 allocation_size
= (SMB_BIG_UINT
)IVAL(pdata
,0);
5755 #ifdef LARGE_SMB_OFF_T
5756 allocation_size
|= (((SMB_BIG_UINT
)IVAL(pdata
,4)) << 32);
5757 #else /* LARGE_SMB_OFF_T */
5758 if (IVAL(pdata
,4) != 0) {
5759 /* more than 32 bits? */
5760 return NT_STATUS_INVALID_PARAMETER
;
5762 #endif /* LARGE_SMB_OFF_T */
5764 DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for file %s to %.0f\n",
5765 fname
, (double)allocation_size
));
5767 if (allocation_size
) {
5768 allocation_size
= smb_roundup(conn
, allocation_size
);
5771 DEBUG(10,("smb_set_file_allocation_info: file %s : setting new allocation size to %.0f\n",
5772 fname
, (double)allocation_size
));
5774 if (fsp
&& fsp
->fh
->fd
!= -1) {
5775 /* Open file handle. */
5776 /* Only change if needed. */
5777 if (allocation_size
!= get_file_size(*psbuf
)) {
5778 if (vfs_allocate_file_space(fsp
, allocation_size
) == -1) {
5779 return map_nt_error_from_unix(errno
);
5782 /* But always update the time. */
5784 * This is equivalent to a write. Ensure it's seen immediately
5785 * if there are no pending writes.
5787 trigger_write_time_update_immediate(fsp
);
5788 return NT_STATUS_OK
;
5791 /* Pathname or stat or directory file. */
5793 status
= open_file_ntcreate(conn
, req
, fname
, psbuf
,
5795 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
5798 FILE_ATTRIBUTE_NORMAL
,
5799 FORCE_OPLOCK_BREAK_TO_NONE
,
5802 if (!NT_STATUS_IS_OK(status
)) {
5803 /* NB. We check for open_was_deferred in the caller. */
5807 /* Only change if needed. */
5808 if (allocation_size
!= get_file_size(*psbuf
)) {
5809 if (vfs_allocate_file_space(new_fsp
, allocation_size
) == -1) {
5810 status
= map_nt_error_from_unix(errno
);
5811 close_file(new_fsp
,NORMAL_CLOSE
);
5816 /* Changing the allocation size should set the last mod time. */
5818 * This is equivalent to a write. Ensure it's seen immediately
5819 * if there are no pending writes.
5821 trigger_write_time_update_immediate(new_fsp
);
5823 close_file(new_fsp
,NORMAL_CLOSE
);
5824 return NT_STATUS_OK
;
5827 /****************************************************************************
5828 Deal with SMB_SET_FILE_END_OF_FILE_INFO.
5829 ****************************************************************************/
5831 static NTSTATUS
smb_set_file_end_of_file_info(connection_struct
*conn
,
5832 struct smb_request
*req
,
5837 SMB_STRUCT_STAT
*psbuf
)
5841 if (total_data
< 8) {
5842 return NT_STATUS_INVALID_PARAMETER
;
5845 size
= IVAL(pdata
,0);
5846 #ifdef LARGE_SMB_OFF_T
5847 size
|= (((SMB_OFF_T
)IVAL(pdata
,4)) << 32);
5848 #else /* LARGE_SMB_OFF_T */
5849 if (IVAL(pdata
,4) != 0) {
5850 /* more than 32 bits? */
5851 return NT_STATUS_INVALID_PARAMETER
;
5853 #endif /* LARGE_SMB_OFF_T */
5854 DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
5855 "file %s to %.0f\n", fname
, (double)size
));
5857 return smb_set_file_size(conn
, req
,
5864 /****************************************************************************
5865 Allow a UNIX info mknod.
5866 ****************************************************************************/
5868 static NTSTATUS
smb_unix_mknod(connection_struct
*conn
,
5872 SMB_STRUCT_STAT
*psbuf
)
5874 uint32 file_type
= IVAL(pdata
,56);
5875 #if defined(HAVE_MAKEDEV)
5876 uint32 dev_major
= IVAL(pdata
,60);
5877 uint32 dev_minor
= IVAL(pdata
,68);
5879 SMB_DEV_T dev
= (SMB_DEV_T
)0;
5880 uint32 raw_unixmode
= IVAL(pdata
,84);
5884 if (total_data
< 100) {
5885 return NT_STATUS_INVALID_PARAMETER
;
5888 status
= unix_perms_from_wire(conn
, psbuf
, raw_unixmode
, PERM_NEW_FILE
, &unixmode
);
5889 if (!NT_STATUS_IS_OK(status
)) {
5893 #if defined(HAVE_MAKEDEV)
5894 dev
= makedev(dev_major
, dev_minor
);
5897 switch (file_type
) {
5898 #if defined(S_IFIFO)
5899 case UNIX_TYPE_FIFO
:
5900 unixmode
|= S_IFIFO
;
5903 #if defined(S_IFSOCK)
5904 case UNIX_TYPE_SOCKET
:
5905 unixmode
|= S_IFSOCK
;
5908 #if defined(S_IFCHR)
5909 case UNIX_TYPE_CHARDEV
:
5910 unixmode
|= S_IFCHR
;
5913 #if defined(S_IFBLK)
5914 case UNIX_TYPE_BLKDEV
:
5915 unixmode
|= S_IFBLK
;
5919 return NT_STATUS_INVALID_PARAMETER
;
5922 DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev %.0f mode \
5923 0%o for file %s\n", (double)dev
, (unsigned int)unixmode
, fname
));
5925 /* Ok - do the mknod. */
5926 if (SMB_VFS_MKNOD(conn
, fname
, unixmode
, dev
) != 0) {
5927 return map_nt_error_from_unix(errno
);
5930 /* If any of the other "set" calls fail we
5931 * don't want to end up with a half-constructed mknod.
5934 if (lp_inherit_perms(SNUM(conn
))) {
5936 conn
, parent_dirname(fname
),
5940 if (SMB_VFS_STAT(conn
, fname
, psbuf
) != 0) {
5941 status
= map_nt_error_from_unix(errno
);
5942 SMB_VFS_UNLINK(conn
,fname
);
5945 return NT_STATUS_OK
;
5948 /****************************************************************************
5949 Deal with SMB_SET_FILE_UNIX_BASIC.
5950 ****************************************************************************/
5952 static NTSTATUS
smb_set_file_unix_basic(connection_struct
*conn
,
5953 struct smb_request
*req
,
5958 SMB_STRUCT_STAT
*psbuf
)
5960 struct timespec ts
[2];
5961 uint32 raw_unixmode
;
5964 uid_t set_owner
= (uid_t
)SMB_UID_NO_CHANGE
;
5965 gid_t set_grp
= (uid_t
)SMB_GID_NO_CHANGE
;
5966 NTSTATUS status
= NT_STATUS_OK
;
5967 bool delete_on_fail
= False
;
5968 enum perm_type ptype
;
5970 if (total_data
< 100) {
5971 return NT_STATUS_INVALID_PARAMETER
;
5974 if(IVAL(pdata
, 0) != SMB_SIZE_NO_CHANGE_LO
&&
5975 IVAL(pdata
, 4) != SMB_SIZE_NO_CHANGE_HI
) {
5976 size
=IVAL(pdata
,0); /* first 8 Bytes are size */
5977 #ifdef LARGE_SMB_OFF_T
5978 size
|= (((SMB_OFF_T
)IVAL(pdata
,4)) << 32);
5979 #else /* LARGE_SMB_OFF_T */
5980 if (IVAL(pdata
,4) != 0) {
5981 /* more than 32 bits? */
5982 return NT_STATUS_INVALID_PARAMETER
;
5984 #endif /* LARGE_SMB_OFF_T */
5987 ts
[0] = interpret_long_date(pdata
+24); /* access_time */
5988 ts
[1] = interpret_long_date(pdata
+32); /* modification_time */
5989 set_owner
= (uid_t
)IVAL(pdata
,40);
5990 set_grp
= (gid_t
)IVAL(pdata
,48);
5991 raw_unixmode
= IVAL(pdata
,84);
5993 if (VALID_STAT(*psbuf
)) {
5994 if (S_ISDIR(psbuf
->st_mode
)) {
5995 ptype
= PERM_EXISTING_DIR
;
5997 ptype
= PERM_EXISTING_FILE
;
6000 ptype
= PERM_NEW_FILE
;
6003 status
= unix_perms_from_wire(conn
, psbuf
, raw_unixmode
, ptype
, &unixmode
);
6004 if (!NT_STATUS_IS_OK(status
)) {
6008 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = %s \
6009 size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
6010 fname
, (double)size
, (unsigned int)set_owner
, (unsigned int)set_grp
, (int)raw_unixmode
));
6012 if (!VALID_STAT(*psbuf
)) {
6014 * The only valid use of this is to create character and block
6015 * devices, and named pipes. This is deprecated (IMHO) and
6016 * a new info level should be used for mknod. JRA.
6019 status
= smb_unix_mknod(conn
,
6024 if (!NT_STATUS_IS_OK(status
)) {
6028 /* Ensure we don't try and change anything else. */
6029 raw_unixmode
= SMB_MODE_NO_CHANGE
;
6030 size
= get_file_size(*psbuf
);
6031 ts
[0] = get_atimespec(psbuf
);
6032 ts
[1] = get_mtimespec(psbuf
);
6034 * We continue here as we might want to change the
6037 delete_on_fail
= True
;
6041 /* Horrible backwards compatibility hack as an old server bug
6042 * allowed a CIFS client bug to remain unnoticed :-(. JRA.
6046 size
= get_file_size(*psbuf
);
6051 * Deal with the UNIX specific mode set.
6054 if (raw_unixmode
!= SMB_MODE_NO_CHANGE
) {
6055 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
6056 (unsigned int)unixmode
, fname
));
6057 if (SMB_VFS_CHMOD(conn
, fname
, unixmode
) != 0) {
6058 return map_nt_error_from_unix(errno
);
6063 * Deal with the UNIX specific uid set.
6066 if ((set_owner
!= (uid_t
)SMB_UID_NO_CHANGE
) && (psbuf
->st_uid
!= set_owner
)) {
6069 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing owner %u for path %s\n",
6070 (unsigned int)set_owner
, fname
));
6072 if (S_ISLNK(psbuf
->st_mode
)) {
6073 ret
= SMB_VFS_LCHOWN(conn
, fname
, set_owner
, (gid_t
)-1);
6075 ret
= SMB_VFS_CHOWN(conn
, fname
, set_owner
, (gid_t
)-1);
6079 status
= map_nt_error_from_unix(errno
);
6080 if (delete_on_fail
) {
6081 SMB_VFS_UNLINK(conn
,fname
);
6088 * Deal with the UNIX specific gid set.
6091 if ((set_grp
!= (uid_t
)SMB_GID_NO_CHANGE
) && (psbuf
->st_gid
!= set_grp
)) {
6092 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
6093 (unsigned int)set_owner
, fname
));
6094 if (SMB_VFS_CHOWN(conn
, fname
, (uid_t
)-1, set_grp
) != 0) {
6095 status
= map_nt_error_from_unix(errno
);
6096 if (delete_on_fail
) {
6097 SMB_VFS_UNLINK(conn
,fname
);
6103 /* Deal with any size changes. */
6105 status
= smb_set_file_size(conn
, req
,
6110 if (!NT_STATUS_IS_OK(status
)) {
6114 /* Deal with any time changes. */
6116 return smb_set_file_time(conn
,
6124 /****************************************************************************
6125 Deal with SMB_SET_FILE_UNIX_INFO2.
6126 ****************************************************************************/
6128 static NTSTATUS
smb_set_file_unix_info2(connection_struct
*conn
,
6129 struct smb_request
*req
,
6134 SMB_STRUCT_STAT
*psbuf
)
6140 if (total_data
< 116) {
6141 return NT_STATUS_INVALID_PARAMETER
;
6144 /* Start by setting all the fields that are common between UNIX_BASIC
6147 status
= smb_set_file_unix_basic(conn
, req
, pdata
, total_data
,
6149 if (!NT_STATUS_IS_OK(status
)) {
6153 smb_fflags
= IVAL(pdata
, 108);
6154 smb_fmask
= IVAL(pdata
, 112);
6156 /* NB: We should only attempt to alter the file flags if the client
6157 * sends a non-zero mask.
6159 if (smb_fmask
!= 0) {
6160 int stat_fflags
= 0;
6162 if (!map_info2_flags_to_sbuf(psbuf
, smb_fflags
, smb_fmask
,
6164 /* Client asked to alter a flag we don't understand. */
6165 return NT_STATUS_INVALID_PARAMETER
;
6168 if (fsp
&& fsp
->fh
->fd
!= -1) {
6169 /* XXX: we should be using SMB_VFS_FCHFLAGS here. */
6170 return NT_STATUS_NOT_SUPPORTED
;
6172 if (SMB_VFS_CHFLAGS(conn
, fname
, stat_fflags
) != 0) {
6173 return map_nt_error_from_unix(errno
);
6178 /* XXX: need to add support for changing the create_time here. You
6179 * can do this for paths on Darwin with setattrlist(2). The right way
6180 * to hook this up is probably by extending the VFS utimes interface.
6183 return NT_STATUS_OK
;
6186 /****************************************************************************
6187 Create a directory with POSIX semantics.
6188 ****************************************************************************/
6190 static NTSTATUS
smb_posix_mkdir(connection_struct
*conn
,
6191 struct smb_request
*req
,
6195 SMB_STRUCT_STAT
*psbuf
,
6196 int *pdata_return_size
)
6198 NTSTATUS status
= NT_STATUS_OK
;
6199 uint32 raw_unixmode
= 0;
6200 uint32 mod_unixmode
= 0;
6201 mode_t unixmode
= (mode_t
)0;
6202 files_struct
*fsp
= NULL
;
6203 uint16 info_level_return
= 0;
6205 char *pdata
= *ppdata
;
6207 if (total_data
< 18) {
6208 return NT_STATUS_INVALID_PARAMETER
;
6211 raw_unixmode
= IVAL(pdata
,8);
6212 /* Next 4 bytes are not yet defined. */
6214 status
= unix_perms_from_wire(conn
, psbuf
, raw_unixmode
, PERM_NEW_DIR
, &unixmode
);
6215 if (!NT_STATUS_IS_OK(status
)) {
6219 mod_unixmode
= (uint32
)unixmode
| FILE_FLAG_POSIX_SEMANTICS
;
6221 DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
6222 fname
, (unsigned int)unixmode
));
6224 status
= open_directory(conn
, req
,
6227 FILE_READ_ATTRIBUTES
, /* Just a stat open */
6228 FILE_SHARE_NONE
, /* Ignored for stat opens */
6235 if (NT_STATUS_IS_OK(status
)) {
6236 close_file(fsp
, NORMAL_CLOSE
);
6239 info_level_return
= SVAL(pdata
,16);
6241 if (info_level_return
== SMB_QUERY_FILE_UNIX_BASIC
) {
6242 *pdata_return_size
= 12 + SMB_FILE_UNIX_BASIC_SIZE
;
6243 } else if (info_level_return
== SMB_QUERY_FILE_UNIX_INFO2
) {
6244 *pdata_return_size
= 12 + SMB_FILE_UNIX_INFO2_SIZE
;
6246 *pdata_return_size
= 12;
6249 /* Realloc the data size */
6250 *ppdata
= (char *)SMB_REALLOC(*ppdata
,*pdata_return_size
);
6251 if (*ppdata
== NULL
) {
6252 *pdata_return_size
= 0;
6253 return NT_STATUS_NO_MEMORY
;
6257 SSVAL(pdata
,0,NO_OPLOCK_RETURN
);
6258 SSVAL(pdata
,2,0); /* No fnum. */
6259 SIVAL(pdata
,4,info
); /* Was directory created. */
6261 switch (info_level_return
) {
6262 case SMB_QUERY_FILE_UNIX_BASIC
:
6263 SSVAL(pdata
,8,SMB_QUERY_FILE_UNIX_BASIC
);
6264 SSVAL(pdata
,10,0); /* Padding. */
6265 store_file_unix_basic(conn
, pdata
+ 12, fsp
, psbuf
);
6267 case SMB_QUERY_FILE_UNIX_INFO2
:
6268 SSVAL(pdata
,8,SMB_QUERY_FILE_UNIX_INFO2
);
6269 SSVAL(pdata
,10,0); /* Padding. */
6270 store_file_unix_basic_info2(conn
, pdata
+ 12, fsp
, psbuf
);
6273 SSVAL(pdata
,8,SMB_NO_INFO_LEVEL_RETURNED
);
6274 SSVAL(pdata
,10,0); /* Padding. */
6281 /****************************************************************************
6282 Open/Create a file with POSIX semantics.
6283 ****************************************************************************/
6285 static NTSTATUS
smb_posix_open(connection_struct
*conn
,
6286 struct smb_request
*req
,
6290 SMB_STRUCT_STAT
*psbuf
,
6291 int *pdata_return_size
)
6293 bool extended_oplock_granted
= False
;
6294 char *pdata
= *ppdata
;
6296 uint32 wire_open_mode
= 0;
6297 uint32 raw_unixmode
= 0;
6298 uint32 mod_unixmode
= 0;
6299 uint32 create_disp
= 0;
6300 uint32 access_mask
= 0;
6301 uint32 create_options
= 0;
6302 NTSTATUS status
= NT_STATUS_OK
;
6303 mode_t unixmode
= (mode_t
)0;
6304 files_struct
*fsp
= NULL
;
6305 int oplock_request
= 0;
6307 uint16 info_level_return
= 0;
6309 if (total_data
< 18) {
6310 return NT_STATUS_INVALID_PARAMETER
;
6313 flags
= IVAL(pdata
,0);
6314 oplock_request
= (flags
& REQUEST_OPLOCK
) ? EXCLUSIVE_OPLOCK
: 0;
6315 if (oplock_request
) {
6316 oplock_request
|= (flags
& REQUEST_BATCH_OPLOCK
) ? BATCH_OPLOCK
: 0;
6319 wire_open_mode
= IVAL(pdata
,4);
6321 if (wire_open_mode
== (SMB_O_CREAT
|SMB_O_DIRECTORY
)) {
6322 return smb_posix_mkdir(conn
, req
,
6330 switch (wire_open_mode
& SMB_ACCMODE
) {
6332 access_mask
= FILE_READ_DATA
;
6335 access_mask
= FILE_WRITE_DATA
;
6338 access_mask
= FILE_READ_DATA
|FILE_WRITE_DATA
;
6341 DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
6342 (unsigned int)wire_open_mode
));
6343 return NT_STATUS_INVALID_PARAMETER
;
6346 wire_open_mode
&= ~SMB_ACCMODE
;
6348 if((wire_open_mode
& (SMB_O_CREAT
| SMB_O_EXCL
)) == (SMB_O_CREAT
| SMB_O_EXCL
)) {
6349 create_disp
= FILE_CREATE
;
6350 } else if((wire_open_mode
& (SMB_O_CREAT
| SMB_O_TRUNC
)) == (SMB_O_CREAT
| SMB_O_TRUNC
)) {
6351 create_disp
= FILE_OVERWRITE_IF
;
6352 } else if((wire_open_mode
& SMB_O_CREAT
) == SMB_O_CREAT
) {
6353 create_disp
= FILE_OPEN_IF
;
6355 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
6356 (unsigned int)wire_open_mode
));
6357 return NT_STATUS_INVALID_PARAMETER
;
6360 raw_unixmode
= IVAL(pdata
,8);
6361 /* Next 4 bytes are not yet defined. */
6363 status
= unix_perms_from_wire(conn
,
6366 VALID_STAT(*psbuf
) ? PERM_EXISTING_FILE
: PERM_NEW_FILE
,
6369 if (!NT_STATUS_IS_OK(status
)) {
6373 mod_unixmode
= (uint32
)unixmode
| FILE_FLAG_POSIX_SEMANTICS
;
6375 if (wire_open_mode
& SMB_O_SYNC
) {
6376 create_options
|= FILE_WRITE_THROUGH
;
6378 if (wire_open_mode
& SMB_O_APPEND
) {
6379 access_mask
|= FILE_APPEND_DATA
;
6381 if (wire_open_mode
& SMB_O_DIRECT
) {
6382 mod_unixmode
|= FILE_FLAG_NO_BUFFERING
;
6385 DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
6387 (unsigned int)wire_open_mode
,
6388 (unsigned int)unixmode
));
6390 status
= open_file_ntcreate(conn
, req
,
6394 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
6396 0, /* no create options yet. */
6402 if (!NT_STATUS_IS_OK(status
)) {
6406 if (oplock_request
&& lp_fake_oplocks(SNUM(conn
))) {
6407 extended_oplock_granted
= True
;
6410 if(oplock_request
&& EXCLUSIVE_OPLOCK_TYPE(fsp
->oplock_type
)) {
6411 extended_oplock_granted
= True
;
6414 info_level_return
= SVAL(pdata
,16);
6416 /* Allocate the correct return size. */
6418 if (info_level_return
== SMB_QUERY_FILE_UNIX_BASIC
) {
6419 *pdata_return_size
= 12 + SMB_FILE_UNIX_BASIC_SIZE
;
6420 } else if (info_level_return
== SMB_QUERY_FILE_UNIX_INFO2
) {
6421 *pdata_return_size
= 12 + SMB_FILE_UNIX_INFO2_SIZE
;
6423 *pdata_return_size
= 12;
6426 /* Realloc the data size */
6427 *ppdata
= (char *)SMB_REALLOC(*ppdata
,*pdata_return_size
);
6428 if (*ppdata
== NULL
) {
6429 close_file(fsp
,ERROR_CLOSE
);
6430 *pdata_return_size
= 0;
6431 return NT_STATUS_NO_MEMORY
;
6435 if (extended_oplock_granted
) {
6436 if (flags
& REQUEST_BATCH_OPLOCK
) {
6437 SSVAL(pdata
,0, BATCH_OPLOCK_RETURN
);
6439 SSVAL(pdata
,0, EXCLUSIVE_OPLOCK_RETURN
);
6441 } else if (fsp
->oplock_type
== LEVEL_II_OPLOCK
) {
6442 SSVAL(pdata
,0, LEVEL_II_OPLOCK_RETURN
);
6444 SSVAL(pdata
,0,NO_OPLOCK_RETURN
);
6447 SSVAL(pdata
,2,fsp
->fnum
);
6448 SIVAL(pdata
,4,info
); /* Was file created etc. */
6450 switch (info_level_return
) {
6451 case SMB_QUERY_FILE_UNIX_BASIC
:
6452 SSVAL(pdata
,8,SMB_QUERY_FILE_UNIX_BASIC
);
6453 SSVAL(pdata
,10,0); /* padding. */
6454 store_file_unix_basic(conn
, pdata
+ 12, fsp
, psbuf
);
6456 case SMB_QUERY_FILE_UNIX_INFO2
:
6457 SSVAL(pdata
,8,SMB_QUERY_FILE_UNIX_INFO2
);
6458 SSVAL(pdata
,10,0); /* padding. */
6459 store_file_unix_basic_info2(conn
, pdata
+ 12, fsp
, psbuf
);
6462 SSVAL(pdata
,8,SMB_NO_INFO_LEVEL_RETURNED
);
6463 SSVAL(pdata
,10,0); /* padding. */
6466 return NT_STATUS_OK
;
6469 /****************************************************************************
6470 Delete a file with POSIX semantics.
6471 ****************************************************************************/
6473 static NTSTATUS
smb_posix_unlink(connection_struct
*conn
,
6474 struct smb_request
*req
,
6478 SMB_STRUCT_STAT
*psbuf
)
6480 NTSTATUS status
= NT_STATUS_OK
;
6481 files_struct
*fsp
= NULL
;
6486 struct share_mode_lock
*lck
= NULL
;
6488 if (total_data
< 2) {
6489 return NT_STATUS_INVALID_PARAMETER
;
6492 flags
= SVAL(pdata
,0);
6494 if (!VALID_STAT(*psbuf
)) {
6495 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
6498 if ((flags
== SMB_POSIX_UNLINK_DIRECTORY_TARGET
) &&
6499 !VALID_STAT_OF_DIR(*psbuf
)) {
6500 return NT_STATUS_NOT_A_DIRECTORY
;
6503 DEBUG(10,("smb_posix_unlink: %s %s\n",
6504 (flags
== SMB_POSIX_UNLINK_DIRECTORY_TARGET
) ? "directory" : "file",
6507 if (VALID_STAT_OF_DIR(*psbuf
)) {
6508 status
= open_directory(conn
, req
,
6512 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
6515 FILE_FLAG_POSIX_SEMANTICS
|0777,
6520 status
= open_file_ntcreate(conn
, req
,
6524 FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
6527 FILE_FLAG_POSIX_SEMANTICS
|0777,
6528 0, /* No oplock, but break existing ones. */
6533 if (!NT_STATUS_IS_OK(status
)) {
6538 * Don't lie to client. If we can't really delete due to
6539 * non-POSIX opens return SHARING_VIOLATION.
6542 lck
= get_share_mode_lock(talloc_tos(), fsp
->file_id
, NULL
, NULL
,
6545 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
6546 "lock for file %s\n", fsp
->fsp_name
));
6547 close_file(fsp
, NORMAL_CLOSE
);
6548 return NT_STATUS_INVALID_PARAMETER
;
6552 * See if others still have the file open. If this is the case, then
6553 * don't delete. If all opens are POSIX delete we can set the delete
6554 * on close disposition.
6556 for (i
=0; i
<lck
->num_share_modes
; i
++) {
6557 struct share_mode_entry
*e
= &lck
->share_modes
[i
];
6558 if (is_valid_share_mode_entry(e
)) {
6559 if (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
) {
6562 /* Fail with sharing violation. */
6563 close_file(fsp
, NORMAL_CLOSE
);
6565 return NT_STATUS_SHARING_VIOLATION
;
6570 * Set the delete on close.
6572 status
= smb_set_file_disposition_info(conn
,
6579 if (!NT_STATUS_IS_OK(status
)) {
6580 close_file(fsp
, NORMAL_CLOSE
);
6585 return close_file(fsp
, NORMAL_CLOSE
);
6588 /****************************************************************************
6589 Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
6590 ****************************************************************************/
6592 static void call_trans2setfilepathinfo(connection_struct
*conn
,
6593 struct smb_request
*req
,
6594 unsigned int tran_call
,
6595 char **pparams
, int total_params
,
6596 char **ppdata
, int total_data
,
6597 unsigned int max_data_bytes
)
6599 char *params
= *pparams
;
6600 char *pdata
= *ppdata
;
6602 SMB_STRUCT_STAT sbuf
;
6604 files_struct
*fsp
= NULL
;
6605 NTSTATUS status
= NT_STATUS_OK
;
6606 int data_return_size
= 0;
6607 TALLOC_CTX
*ctx
= talloc_tos();
6610 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
6616 if (tran_call
== TRANSACT2_SETFILEINFO
) {
6617 if (total_params
< 4) {
6618 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
6622 fsp
= file_fsp(SVAL(params
,0));
6623 /* Basic check for non-null fsp. */
6624 if (!check_fsp_open(conn
, req
, fsp
, ¤t_user
)) {
6627 info_level
= SVAL(params
,2);
6629 fname
= talloc_strdup(talloc_tos(),fsp
->fsp_name
);
6631 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
6635 if(fsp
->is_directory
|| fsp
->fh
->fd
== -1) {
6637 * This is actually a SETFILEINFO on a directory
6638 * handle (returned from an NT SMB). NT5.0 seems
6639 * to do this call. JRA.
6641 if (INFO_LEVEL_IS_UNIX(info_level
)) {
6642 /* Always do lstat for UNIX calls. */
6643 if (SMB_VFS_LSTAT(conn
,fname
,&sbuf
)) {
6644 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname
,strerror(errno
)));
6645 reply_unixerror(req
,ERRDOS
,ERRbadpath
);
6649 if (SMB_VFS_STAT(conn
,fname
,&sbuf
) != 0) {
6650 DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname
,strerror(errno
)));
6651 reply_unixerror(req
,ERRDOS
,ERRbadpath
);
6655 } else if (fsp
->print_file
) {
6657 * Doing a DELETE_ON_CLOSE should cancel a print job.
6659 if ((info_level
== SMB_SET_FILE_DISPOSITION_INFO
) && CVAL(pdata
,0)) {
6660 fsp
->fh
->private_options
|= FILE_DELETE_ON_CLOSE
;
6662 DEBUG(3,("call_trans2setfilepathinfo: Cancelling print job (%s)\n", fsp
->fsp_name
));
6665 send_trans2_replies(conn
, req
, params
, 2,
6670 reply_unixerror(req
, ERRDOS
, ERRbadpath
);
6675 * Original code - this is an open file.
6677 if (!check_fsp(conn
, req
, fsp
, ¤t_user
)) {
6681 if (SMB_VFS_FSTAT(fsp
, &sbuf
) != 0) {
6682 DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp
->fnum
, strerror(errno
)));
6683 reply_unixerror(req
, ERRDOS
, ERRbadfid
);
6689 if (total_params
< 7) {
6690 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
6694 info_level
= SVAL(params
,0);
6695 srvstr_get_path(ctx
, params
, req
->flags2
, &fname
, ¶ms
[6],
6696 total_params
- 6, STR_TERMINATE
,
6698 if (!NT_STATUS_IS_OK(status
)) {
6699 reply_nterror(req
, status
);
6703 status
= resolve_dfspath(ctx
, conn
,
6704 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
6707 if (!NT_STATUS_IS_OK(status
)) {
6708 if (NT_STATUS_EQUAL(status
,NT_STATUS_PATH_NOT_COVERED
)) {
6709 reply_botherror(req
,
6710 NT_STATUS_PATH_NOT_COVERED
,
6711 ERRSRV
, ERRbadpath
);
6714 reply_nterror(req
, status
);
6718 status
= unix_convert(ctx
, conn
, fname
, False
,
6719 &fname
, NULL
, &sbuf
);
6720 if (!NT_STATUS_IS_OK(status
)) {
6721 reply_nterror(req
, status
);
6725 status
= check_name(conn
, fname
);
6726 if (!NT_STATUS_IS_OK(status
)) {
6727 reply_nterror(req
, status
);
6731 if (INFO_LEVEL_IS_UNIX(info_level
)) {
6733 * For CIFS UNIX extensions the target name may not exist.
6736 /* Always do lstat for UNIX calls. */
6737 SMB_VFS_LSTAT(conn
,fname
,&sbuf
);
6739 } else if (!VALID_STAT(sbuf
) && SMB_VFS_STAT(conn
,fname
,&sbuf
)) {
6740 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname
,strerror(errno
)));
6741 reply_unixerror(req
, ERRDOS
, ERRbadpath
);
6746 if (!CAN_WRITE(conn
)) {
6747 reply_doserror(req
, ERRSRV
, ERRaccess
);
6751 if (INFO_LEVEL_IS_UNIX(info_level
) && !lp_unix_extensions()) {
6752 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
6756 DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d totdata=%d\n",
6757 tran_call
,fname
, fsp
? fsp
->fnum
: -1, info_level
,total_data
));
6759 /* Realloc the parameter size */
6760 *pparams
= (char *)SMB_REALLOC(*pparams
,2);
6761 if (*pparams
== NULL
) {
6762 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
6769 switch (info_level
) {
6771 case SMB_INFO_STANDARD
:
6773 status
= smb_set_info_standard(conn
,
6782 case SMB_INFO_SET_EA
:
6784 status
= smb_info_set_ea(conn
,
6792 case SMB_SET_FILE_BASIC_INFO
:
6793 case SMB_FILE_BASIC_INFORMATION
:
6795 status
= smb_set_file_basic_info(conn
,
6804 case SMB_FILE_ALLOCATION_INFORMATION
:
6805 case SMB_SET_FILE_ALLOCATION_INFO
:
6807 status
= smb_set_file_allocation_info(conn
, req
,
6816 case SMB_FILE_END_OF_FILE_INFORMATION
:
6817 case SMB_SET_FILE_END_OF_FILE_INFO
:
6819 status
= smb_set_file_end_of_file_info(conn
, req
,
6828 case SMB_FILE_DISPOSITION_INFORMATION
:
6829 case SMB_SET_FILE_DISPOSITION_INFO
: /* Set delete on close for open file. */
6832 /* JRA - We used to just ignore this on a path ?
6833 * Shouldn't this be invalid level on a pathname
6836 if (tran_call
!= TRANSACT2_SETFILEINFO
) {
6837 return ERROR_NT(NT_STATUS_INVALID_LEVEL
);
6840 status
= smb_set_file_disposition_info(conn
,
6849 case SMB_FILE_POSITION_INFORMATION
:
6851 status
= smb_file_position_information(conn
,
6858 /* From tridge Samba4 :
6859 * MODE_INFORMATION in setfileinfo (I have no
6860 * idea what "mode information" on a file is - it takes a value of 0,
6861 * 2, 4 or 6. What could it be?).
6864 case SMB_FILE_MODE_INFORMATION
:
6866 status
= smb_file_mode_information(conn
,
6873 * CIFS UNIX extensions.
6876 case SMB_SET_FILE_UNIX_BASIC
:
6878 status
= smb_set_file_unix_basic(conn
, req
,
6887 case SMB_SET_FILE_UNIX_INFO2
:
6889 status
= smb_set_file_unix_info2(conn
, req
,
6898 case SMB_SET_FILE_UNIX_LINK
:
6900 if (tran_call
!= TRANSACT2_SETPATHINFO
) {
6901 /* We must have a pathname for this. */
6902 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
6905 status
= smb_set_file_unix_link(conn
, req
, pdata
,
6910 case SMB_SET_FILE_UNIX_HLINK
:
6912 if (tran_call
!= TRANSACT2_SETPATHINFO
) {
6913 /* We must have a pathname for this. */
6914 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
6917 status
= smb_set_file_unix_hlink(conn
, req
,
6923 case SMB_FILE_RENAME_INFORMATION
:
6925 status
= smb_file_rename_information(conn
, req
,
6931 #if defined(HAVE_POSIX_ACLS)
6932 case SMB_SET_POSIX_ACL
:
6934 status
= smb_set_posix_acl(conn
,
6944 case SMB_SET_POSIX_LOCK
:
6946 if (tran_call
!= TRANSACT2_SETFILEINFO
) {
6947 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
6950 status
= smb_set_posix_lock(conn
, req
,
6951 pdata
, total_data
, fsp
);
6955 case SMB_POSIX_PATH_OPEN
:
6957 if (tran_call
!= TRANSACT2_SETPATHINFO
) {
6958 /* We must have a pathname for this. */
6959 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
6963 status
= smb_posix_open(conn
, req
,
6972 case SMB_POSIX_PATH_UNLINK
:
6974 if (tran_call
!= TRANSACT2_SETPATHINFO
) {
6975 /* We must have a pathname for this. */
6976 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
6980 status
= smb_posix_unlink(conn
, req
,
6989 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
6994 if (!NT_STATUS_IS_OK(status
)) {
6995 if (open_was_deferred(req
->mid
)) {
6996 /* We have re-scheduled this call. */
6999 if (blocking_lock_was_deferred(req
->mid
)) {
7000 /* We have re-scheduled this call. */
7003 if (NT_STATUS_EQUAL(status
,NT_STATUS_PATH_NOT_COVERED
)) {
7004 reply_botherror(req
, NT_STATUS_PATH_NOT_COVERED
,
7005 ERRSRV
, ERRbadpath
);
7008 if (info_level
== SMB_POSIX_PATH_OPEN
) {
7009 reply_openerror(req
, status
);
7013 reply_nterror(req
, status
);
7018 send_trans2_replies(conn
, req
, params
, 2, *ppdata
, data_return_size
,
7024 /****************************************************************************
7025 Reply to a TRANS2_MKDIR (make directory with extended attributes).
7026 ****************************************************************************/
7028 static void call_trans2mkdir(connection_struct
*conn
, struct smb_request
*req
,
7029 char **pparams
, int total_params
,
7030 char **ppdata
, int total_data
,
7031 unsigned int max_data_bytes
)
7033 char *params
= *pparams
;
7034 char *pdata
= *ppdata
;
7035 char *directory
= NULL
;
7036 SMB_STRUCT_STAT sbuf
;
7037 NTSTATUS status
= NT_STATUS_OK
;
7038 struct ea_list
*ea_list
= NULL
;
7039 TALLOC_CTX
*ctx
= talloc_tos();
7041 if (!CAN_WRITE(conn
)) {
7042 reply_doserror(req
, ERRSRV
, ERRaccess
);
7046 if (total_params
< 5) {
7047 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7051 srvstr_get_path(ctx
, params
, req
->flags2
, &directory
, ¶ms
[4],
7052 total_params
- 4, STR_TERMINATE
,
7054 if (!NT_STATUS_IS_OK(status
)) {
7055 reply_nterror(req
, status
);
7059 DEBUG(3,("call_trans2mkdir : name = %s\n", directory
));
7061 status
= unix_convert(ctx
, conn
, directory
, False
, &directory
, NULL
, &sbuf
);
7062 if (!NT_STATUS_IS_OK(status
)) {
7063 reply_nterror(req
, status
);
7067 status
= check_name(conn
, directory
);
7068 if (!NT_STATUS_IS_OK(status
)) {
7069 DEBUG(5,("call_trans2mkdir error (%s)\n", nt_errstr(status
)));
7070 reply_nterror(req
, status
);
7074 /* Any data in this call is an EA list. */
7075 if (total_data
&& (total_data
!= 4) && !lp_ea_support(SNUM(conn
))) {
7076 reply_nterror(req
, NT_STATUS_EAS_NOT_SUPPORTED
);
7081 * OS/2 workplace shell seems to send SET_EA requests of "null"
7082 * length (4 bytes containing IVAL 4).
7083 * They seem to have no effect. Bug #3212. JRA.
7086 if (total_data
!= 4) {
7087 if (total_data
< 10) {
7088 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7092 if (IVAL(pdata
,0) > total_data
) {
7093 DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
7094 IVAL(pdata
,0), (unsigned int)total_data
));
7095 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7099 ea_list
= read_ea_list(talloc_tos(), pdata
+ 4,
7102 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7106 /* If total_data == 4 Windows doesn't care what values
7107 * are placed in that field, it just ignores them.
7108 * The System i QNTC IBM SMB client puts bad values here,
7109 * so ignore them. */
7111 status
= create_directory(conn
, req
, directory
);
7113 if (!NT_STATUS_IS_OK(status
)) {
7114 reply_nterror(req
, status
);
7118 /* Try and set any given EA. */
7120 status
= set_ea(conn
, NULL
, directory
, ea_list
);
7121 if (!NT_STATUS_IS_OK(status
)) {
7122 reply_nterror(req
, status
);
7127 /* Realloc the parameter and data sizes */
7128 *pparams
= (char *)SMB_REALLOC(*pparams
,2);
7129 if(*pparams
== NULL
) {
7130 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
7137 send_trans2_replies(conn
, req
, params
, 2, *ppdata
, 0, max_data_bytes
);
7142 /****************************************************************************
7143 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
7144 We don't actually do this - we just send a null response.
7145 ****************************************************************************/
7147 static void call_trans2findnotifyfirst(connection_struct
*conn
,
7148 struct smb_request
*req
,
7149 char **pparams
, int total_params
,
7150 char **ppdata
, int total_data
,
7151 unsigned int max_data_bytes
)
7153 static uint16 fnf_handle
= 257;
7154 char *params
= *pparams
;
7157 if (total_params
< 6) {
7158 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7162 info_level
= SVAL(params
,4);
7163 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level
));
7165 switch (info_level
) {
7170 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
7174 /* Realloc the parameter and data sizes */
7175 *pparams
= (char *)SMB_REALLOC(*pparams
,6);
7176 if (*pparams
== NULL
) {
7177 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
7182 SSVAL(params
,0,fnf_handle
);
7183 SSVAL(params
,2,0); /* No changes */
7184 SSVAL(params
,4,0); /* No EA errors */
7191 send_trans2_replies(conn
, req
, params
, 6, *ppdata
, 0, max_data_bytes
);
7196 /****************************************************************************
7197 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
7198 changes). Currently this does nothing.
7199 ****************************************************************************/
7201 static void call_trans2findnotifynext(connection_struct
*conn
,
7202 struct smb_request
*req
,
7203 char **pparams
, int total_params
,
7204 char **ppdata
, int total_data
,
7205 unsigned int max_data_bytes
)
7207 char *params
= *pparams
;
7209 DEBUG(3,("call_trans2findnotifynext\n"));
7211 /* Realloc the parameter and data sizes */
7212 *pparams
= (char *)SMB_REALLOC(*pparams
,4);
7213 if (*pparams
== NULL
) {
7214 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
7219 SSVAL(params
,0,0); /* No changes */
7220 SSVAL(params
,2,0); /* No EA errors */
7222 send_trans2_replies(conn
, req
, params
, 4, *ppdata
, 0, max_data_bytes
);
7227 /****************************************************************************
7228 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
7229 ****************************************************************************/
7231 static void call_trans2getdfsreferral(connection_struct
*conn
,
7232 struct smb_request
*req
,
7233 char **pparams
, int total_params
,
7234 char **ppdata
, int total_data
,
7235 unsigned int max_data_bytes
)
7237 char *params
= *pparams
;
7238 char *pathname
= NULL
;
7240 int max_referral_level
;
7241 NTSTATUS status
= NT_STATUS_OK
;
7242 TALLOC_CTX
*ctx
= talloc_tos();
7244 DEBUG(10,("call_trans2getdfsreferral\n"));
7246 if (total_params
< 3) {
7247 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7251 max_referral_level
= SVAL(params
,0);
7253 if(!lp_host_msdfs()) {
7254 reply_doserror(req
, ERRDOS
, ERRbadfunc
);
7258 srvstr_pull_talloc(ctx
, params
, req
->flags2
, &pathname
, ¶ms
[2],
7259 total_params
- 2, STR_TERMINATE
);
7261 reply_nterror(req
, NT_STATUS_NOT_FOUND
);
7264 if((reply_size
= setup_dfs_referral(conn
, pathname
, max_referral_level
,
7265 ppdata
,&status
)) < 0) {
7266 reply_nterror(req
, status
);
7270 SSVAL(req
->inbuf
, smb_flg2
,
7271 SVAL(req
->inbuf
,smb_flg2
) | FLAGS2_DFS_PATHNAMES
);
7272 send_trans2_replies(conn
, req
,0,0,*ppdata
,reply_size
, max_data_bytes
);
7277 #define LMCAT_SPL 0x53
7278 #define LMFUNC_GETJOBID 0x60
7280 /****************************************************************************
7281 Reply to a TRANS2_IOCTL - used for OS/2 printing.
7282 ****************************************************************************/
7284 static void call_trans2ioctl(connection_struct
*conn
,
7285 struct smb_request
*req
,
7286 char **pparams
, int total_params
,
7287 char **ppdata
, int total_data
,
7288 unsigned int max_data_bytes
)
7290 char *pdata
= *ppdata
;
7291 files_struct
*fsp
= file_fsp(SVAL(req
->inbuf
,smb_vwv15
));
7293 /* check for an invalid fid before proceeding */
7296 reply_doserror(req
, ERRDOS
, ERRbadfid
);
7300 if ((SVAL(req
->inbuf
,(smb_setup
+4)) == LMCAT_SPL
)
7301 && (SVAL(req
->inbuf
,(smb_setup
+6)) == LMFUNC_GETJOBID
)) {
7302 *ppdata
= (char *)SMB_REALLOC(*ppdata
, 32);
7303 if (*ppdata
== NULL
) {
7304 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
7309 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
7310 CAN ACCEPT THIS IN UNICODE. JRA. */
7312 SSVAL(pdata
,0,fsp
->rap_print_jobid
); /* Job number */
7313 srvstr_push(pdata
, req
->flags2
, pdata
+ 2,
7314 global_myname(), 15,
7315 STR_ASCII
|STR_TERMINATE
); /* Our NetBIOS name */
7316 srvstr_push(pdata
, req
->flags2
, pdata
+18,
7317 lp_servicename(SNUM(conn
)), 13,
7318 STR_ASCII
|STR_TERMINATE
); /* Service name */
7319 send_trans2_replies(conn
, req
, *pparams
, 0, *ppdata
, 32,
7324 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
7325 reply_doserror(req
, ERRSRV
, ERRerror
);
7328 /****************************************************************************
7329 Reply to a SMBfindclose (stop trans2 directory search).
7330 ****************************************************************************/
7332 void reply_findclose(struct smb_request
*req
)
7336 START_PROFILE(SMBfindclose
);
7339 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7340 END_PROFILE(SMBfindclose
);
7344 dptr_num
= SVALS(req
->inbuf
,smb_vwv0
);
7346 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num
));
7348 dptr_close(&dptr_num
);
7350 reply_outbuf(req
, 0, 0);
7352 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num
));
7354 END_PROFILE(SMBfindclose
);
7358 /****************************************************************************
7359 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
7360 ****************************************************************************/
7362 void reply_findnclose(struct smb_request
*req
)
7366 START_PROFILE(SMBfindnclose
);
7369 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7370 END_PROFILE(SMBfindnclose
);
7374 dptr_num
= SVAL(req
->inbuf
,smb_vwv0
);
7376 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num
));
7378 /* We never give out valid handles for a
7379 findnotifyfirst - so any dptr_num is ok here.
7382 reply_outbuf(req
, 0, 0);
7384 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num
));
7386 END_PROFILE(SMBfindnclose
);
7390 static void handle_trans2(connection_struct
*conn
, struct smb_request
*req
,
7391 struct trans_state
*state
)
7393 if (Protocol
>= PROTOCOL_NT1
) {
7394 req
->flags2
|= 0x40; /* IS_LONG_NAME */
7395 SSVAL(req
->inbuf
,smb_flg2
,req
->flags2
);
7398 if (conn
->encrypt_level
== Required
&& !req
->encrypted
) {
7399 if (state
->call
!= TRANSACT2_QFSINFO
&&
7400 state
->call
!= TRANSACT2_SETFSINFO
) {
7401 DEBUG(0,("handle_trans2: encryption required "
7403 (unsigned int)state
->call
));
7404 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
7409 /* Now we must call the relevant TRANS2 function */
7410 switch(state
->call
) {
7411 case TRANSACT2_OPEN
:
7413 START_PROFILE(Trans2_open
);
7414 call_trans2open(conn
, req
,
7415 &state
->param
, state
->total_param
,
7416 &state
->data
, state
->total_data
,
7417 state
->max_data_return
);
7418 END_PROFILE(Trans2_open
);
7422 case TRANSACT2_FINDFIRST
:
7424 START_PROFILE(Trans2_findfirst
);
7425 call_trans2findfirst(conn
, req
,
7426 &state
->param
, state
->total_param
,
7427 &state
->data
, state
->total_data
,
7428 state
->max_data_return
);
7429 END_PROFILE(Trans2_findfirst
);
7433 case TRANSACT2_FINDNEXT
:
7435 START_PROFILE(Trans2_findnext
);
7436 call_trans2findnext(conn
, req
,
7437 &state
->param
, state
->total_param
,
7438 &state
->data
, state
->total_data
,
7439 state
->max_data_return
);
7440 END_PROFILE(Trans2_findnext
);
7444 case TRANSACT2_QFSINFO
:
7446 START_PROFILE(Trans2_qfsinfo
);
7447 call_trans2qfsinfo(conn
, req
,
7448 &state
->param
, state
->total_param
,
7449 &state
->data
, state
->total_data
,
7450 state
->max_data_return
);
7451 END_PROFILE(Trans2_qfsinfo
);
7455 case TRANSACT2_SETFSINFO
:
7457 START_PROFILE(Trans2_setfsinfo
);
7458 call_trans2setfsinfo(conn
, req
,
7459 &state
->param
, state
->total_param
,
7460 &state
->data
, state
->total_data
,
7461 state
->max_data_return
);
7462 END_PROFILE(Trans2_setfsinfo
);
7466 case TRANSACT2_QPATHINFO
:
7467 case TRANSACT2_QFILEINFO
:
7469 START_PROFILE(Trans2_qpathinfo
);
7470 call_trans2qfilepathinfo(conn
, req
, state
->call
,
7471 &state
->param
, state
->total_param
,
7472 &state
->data
, state
->total_data
,
7473 state
->max_data_return
);
7474 END_PROFILE(Trans2_qpathinfo
);
7478 case TRANSACT2_SETPATHINFO
:
7479 case TRANSACT2_SETFILEINFO
:
7481 START_PROFILE(Trans2_setpathinfo
);
7482 call_trans2setfilepathinfo(conn
, req
, state
->call
,
7483 &state
->param
, state
->total_param
,
7484 &state
->data
, state
->total_data
,
7485 state
->max_data_return
);
7486 END_PROFILE(Trans2_setpathinfo
);
7490 case TRANSACT2_FINDNOTIFYFIRST
:
7492 START_PROFILE(Trans2_findnotifyfirst
);
7493 call_trans2findnotifyfirst(conn
, req
,
7494 &state
->param
, state
->total_param
,
7495 &state
->data
, state
->total_data
,
7496 state
->max_data_return
);
7497 END_PROFILE(Trans2_findnotifyfirst
);
7501 case TRANSACT2_FINDNOTIFYNEXT
:
7503 START_PROFILE(Trans2_findnotifynext
);
7504 call_trans2findnotifynext(conn
, req
,
7505 &state
->param
, state
->total_param
,
7506 &state
->data
, state
->total_data
,
7507 state
->max_data_return
);
7508 END_PROFILE(Trans2_findnotifynext
);
7512 case TRANSACT2_MKDIR
:
7514 START_PROFILE(Trans2_mkdir
);
7515 call_trans2mkdir(conn
, req
,
7516 &state
->param
, state
->total_param
,
7517 &state
->data
, state
->total_data
,
7518 state
->max_data_return
);
7519 END_PROFILE(Trans2_mkdir
);
7523 case TRANSACT2_GET_DFS_REFERRAL
:
7525 START_PROFILE(Trans2_get_dfs_referral
);
7526 call_trans2getdfsreferral(conn
, req
,
7527 &state
->param
, state
->total_param
,
7528 &state
->data
, state
->total_data
,
7529 state
->max_data_return
);
7530 END_PROFILE(Trans2_get_dfs_referral
);
7534 case TRANSACT2_IOCTL
:
7536 START_PROFILE(Trans2_ioctl
);
7537 call_trans2ioctl(conn
, req
,
7538 &state
->param
, state
->total_param
,
7539 &state
->data
, state
->total_data
,
7540 state
->max_data_return
);
7541 END_PROFILE(Trans2_ioctl
);
7546 /* Error in request */
7547 DEBUG(2,("Unknown request %d in trans2 call\n", state
->call
));
7548 reply_doserror(req
, ERRSRV
,ERRerror
);
7552 /****************************************************************************
7553 Reply to a SMBtrans2.
7554 ****************************************************************************/
7556 void reply_trans2(struct smb_request
*req
)
7558 connection_struct
*conn
= req
->conn
;
7563 unsigned int tran_call
;
7565 unsigned int av_size
;
7566 struct trans_state
*state
;
7569 START_PROFILE(SMBtrans2
);
7571 if (req
->wct
< 14) {
7572 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7573 END_PROFILE(SMBtrans2
);
7577 dsoff
= SVAL(req
->inbuf
, smb_dsoff
);
7578 dscnt
= SVAL(req
->inbuf
, smb_dscnt
);
7579 psoff
= SVAL(req
->inbuf
, smb_psoff
);
7580 pscnt
= SVAL(req
->inbuf
, smb_pscnt
);
7581 tran_call
= SVAL(req
->inbuf
, smb_setup0
);
7582 size
= smb_len(req
->inbuf
) + 4;
7583 av_size
= smb_len(req
->inbuf
);
7585 result
= allow_new_trans(conn
->pending_trans
, req
->mid
);
7586 if (!NT_STATUS_IS_OK(result
)) {
7587 DEBUG(2, ("Got invalid trans2 request: %s\n",
7588 nt_errstr(result
)));
7589 reply_nterror(req
, result
);
7590 END_PROFILE(SMBtrans2
);
7595 switch (tran_call
) {
7596 /* List the allowed trans2 calls on IPC$ */
7597 case TRANSACT2_OPEN
:
7598 case TRANSACT2_GET_DFS_REFERRAL
:
7599 case TRANSACT2_QFILEINFO
:
7600 case TRANSACT2_QFSINFO
:
7601 case TRANSACT2_SETFSINFO
:
7604 reply_doserror(req
, ERRSRV
, ERRaccess
);
7605 END_PROFILE(SMBtrans2
);
7610 if ((state
= TALLOC_P(conn
->mem_ctx
, struct trans_state
)) == NULL
) {
7611 DEBUG(0, ("talloc failed\n"));
7612 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
7613 END_PROFILE(SMBtrans2
);
7617 state
->cmd
= SMBtrans2
;
7619 state
->mid
= req
->mid
;
7620 state
->vuid
= req
->vuid
;
7621 state
->setup_count
= SVAL(req
->inbuf
, smb_suwcnt
);
7622 state
->setup
= NULL
;
7623 state
->total_param
= SVAL(req
->inbuf
, smb_tpscnt
);
7624 state
->param
= NULL
;
7625 state
->total_data
= SVAL(req
->inbuf
, smb_tdscnt
);
7627 state
->max_param_return
= SVAL(req
->inbuf
, smb_mprcnt
);
7628 state
->max_data_return
= SVAL(req
->inbuf
, smb_mdrcnt
);
7629 state
->max_setup_return
= SVAL(req
->inbuf
, smb_msrcnt
);
7630 state
->close_on_completion
= BITSETW(req
->inbuf
+smb_vwv5
,0);
7631 state
->one_way
= BITSETW(req
->inbuf
+smb_vwv5
,1);
7633 state
->call
= tran_call
;
7635 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
7636 is so as a sanity check */
7637 if (state
->setup_count
!= 1) {
7639 * Need to have rc=0 for ioctl to get job id for OS/2.
7640 * Network printing will fail if function is not successful.
7641 * Similar function in reply.c will be used if protocol
7642 * is LANMAN1.0 instead of LM1.2X002.
7643 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
7644 * outbuf doesn't have to be set(only job id is used).
7646 if ( (state
->setup_count
== 4)
7647 && (tran_call
== TRANSACT2_IOCTL
)
7648 && (SVAL(req
->inbuf
,(smb_setup
+4)) == LMCAT_SPL
)
7649 && (SVAL(req
->inbuf
,(smb_setup
+6)) == LMFUNC_GETJOBID
)) {
7650 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
7652 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state
->setup_count
));
7653 DEBUG(2,("Transaction is %d\n",tran_call
));
7655 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7656 END_PROFILE(SMBtrans2
);
7661 if ((dscnt
> state
->total_data
) || (pscnt
> state
->total_param
))
7664 if (state
->total_data
) {
7665 /* Can't use talloc here, the core routines do realloc on the
7666 * params and data. */
7667 state
->data
= (char *)SMB_MALLOC(state
->total_data
);
7668 if (state
->data
== NULL
) {
7669 DEBUG(0,("reply_trans2: data malloc fail for %u "
7670 "bytes !\n", (unsigned int)state
->total_data
));
7672 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
7673 END_PROFILE(SMBtrans2
);
7677 if (dscnt
> state
->total_data
||
7678 dsoff
+dscnt
< dsoff
) {
7682 if (dsoff
> av_size
||
7684 dsoff
+dscnt
> av_size
) {
7688 memcpy(state
->data
,smb_base(req
->inbuf
)+dsoff
,dscnt
);
7691 if (state
->total_param
) {
7692 /* Can't use talloc here, the core routines do realloc on the
7693 * params and data. */
7694 state
->param
= (char *)SMB_MALLOC(state
->total_param
);
7695 if (state
->param
== NULL
) {
7696 DEBUG(0,("reply_trans: param malloc fail for %u "
7697 "bytes !\n", (unsigned int)state
->total_param
));
7698 SAFE_FREE(state
->data
);
7700 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
7701 END_PROFILE(SMBtrans2
);
7705 if (pscnt
> state
->total_param
||
7706 psoff
+pscnt
< psoff
) {
7710 if (psoff
> av_size
||
7712 psoff
+pscnt
> av_size
) {
7716 memcpy(state
->param
,smb_base(req
->inbuf
)+psoff
,pscnt
);
7719 state
->received_data
= dscnt
;
7720 state
->received_param
= pscnt
;
7722 if ((state
->received_param
== state
->total_param
) &&
7723 (state
->received_data
== state
->total_data
)) {
7725 handle_trans2(conn
, req
, state
);
7727 SAFE_FREE(state
->data
);
7728 SAFE_FREE(state
->param
);
7730 END_PROFILE(SMBtrans2
);
7734 DLIST_ADD(conn
->pending_trans
, state
);
7736 /* We need to send an interim response then receive the rest
7737 of the parameter/data bytes */
7738 reply_outbuf(req
, 0, 0);
7739 show_msg((char *)req
->outbuf
);
7740 END_PROFILE(SMBtrans2
);
7745 DEBUG(0,("reply_trans2: invalid trans parameters\n"));
7746 SAFE_FREE(state
->data
);
7747 SAFE_FREE(state
->param
);
7749 END_PROFILE(SMBtrans2
);
7750 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7754 /****************************************************************************
7755 Reply to a SMBtranss2
7756 ****************************************************************************/
7758 void reply_transs2(struct smb_request
*req
)
7760 connection_struct
*conn
= req
->conn
;
7761 unsigned int pcnt
,poff
,dcnt
,doff
,pdisp
,ddisp
;
7762 struct trans_state
*state
;
7764 unsigned int av_size
;
7766 START_PROFILE(SMBtranss2
);
7768 show_msg((char *)req
->inbuf
);
7771 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7772 END_PROFILE(SMBtranss2
);
7776 size
= smb_len(req
->inbuf
)+4;
7777 av_size
= smb_len(req
->inbuf
);
7779 for (state
= conn
->pending_trans
; state
!= NULL
;
7780 state
= state
->next
) {
7781 if (state
->mid
== req
->mid
) {
7786 if ((state
== NULL
) || (state
->cmd
!= SMBtrans2
)) {
7787 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7788 END_PROFILE(SMBtranss2
);
7792 /* Revise state->total_param and state->total_data in case they have
7793 changed downwards */
7795 if (SVAL(req
->inbuf
, smb_tpscnt
) < state
->total_param
)
7796 state
->total_param
= SVAL(req
->inbuf
, smb_tpscnt
);
7797 if (SVAL(req
->inbuf
, smb_tdscnt
) < state
->total_data
)
7798 state
->total_data
= SVAL(req
->inbuf
, smb_tdscnt
);
7800 pcnt
= SVAL(req
->inbuf
, smb_spscnt
);
7801 poff
= SVAL(req
->inbuf
, smb_spsoff
);
7802 pdisp
= SVAL(req
->inbuf
, smb_spsdisp
);
7804 dcnt
= SVAL(req
->inbuf
, smb_sdscnt
);
7805 doff
= SVAL(req
->inbuf
, smb_sdsoff
);
7806 ddisp
= SVAL(req
->inbuf
, smb_sdsdisp
);
7808 state
->received_param
+= pcnt
;
7809 state
->received_data
+= dcnt
;
7811 if ((state
->received_data
> state
->total_data
) ||
7812 (state
->received_param
> state
->total_param
))
7816 if (pdisp
> state
->total_param
||
7817 pcnt
> state
->total_param
||
7818 pdisp
+pcnt
> state
->total_param
||
7819 pdisp
+pcnt
< pdisp
) {
7823 if (poff
> av_size
||
7825 poff
+pcnt
> av_size
||
7830 memcpy(state
->param
+pdisp
,smb_base(req
->inbuf
)+poff
,
7835 if (ddisp
> state
->total_data
||
7836 dcnt
> state
->total_data
||
7837 ddisp
+dcnt
> state
->total_data
||
7838 ddisp
+dcnt
< ddisp
) {
7842 if (doff
> av_size
||
7844 doff
+dcnt
> av_size
||
7849 memcpy(state
->data
+ddisp
, smb_base(req
->inbuf
)+doff
,
7853 if ((state
->received_param
< state
->total_param
) ||
7854 (state
->received_data
< state
->total_data
)) {
7855 END_PROFILE(SMBtranss2
);
7860 * construct_reply_common will copy smb_com from inbuf to
7861 * outbuf. SMBtranss2 is wrong here.
7863 SCVAL(req
->inbuf
,smb_com
,SMBtrans2
);
7865 handle_trans2(conn
, req
, state
);
7867 DLIST_REMOVE(conn
->pending_trans
, state
);
7868 SAFE_FREE(state
->data
);
7869 SAFE_FREE(state
->param
);
7872 END_PROFILE(SMBtranss2
);
7877 DEBUG(0,("reply_transs2: invalid trans parameters\n"));
7878 DLIST_REMOVE(conn
->pending_trans
, state
);
7879 SAFE_FREE(state
->data
);
7880 SAFE_FREE(state
->param
);
7882 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7883 END_PROFILE(SMBtranss2
);