2 Unix SMB/CIFS implementation.
3 SMB transaction2 handling
4 Copyright (C) Jeremy Allison 1994-2007
5 Copyright (C) Stefan (metze) Metzmacher 2003
6 Copyright (C) Volker Lendecke 2005-2007
7 Copyright (C) Steve French 2005
8 Copyright (C) James Peach 2006-2007
10 Extensively modified by Andrew Tridgell, 1995
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 3 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>.
28 #include "smbd/globals.h"
29 #include "../libcli/auth/libcli_auth.h"
31 #define DIR_ENTRY_SAFETY_MARGIN 4096
33 static char *store_file_unix_basic(connection_struct
*conn
,
36 const SMB_STRUCT_STAT
*psbuf
);
38 static char *store_file_unix_basic_info2(connection_struct
*conn
,
41 const SMB_STRUCT_STAT
*psbuf
);
43 /********************************************************************
44 Roundup a value to the nearest allocation roundup size boundary.
45 Only do this for Windows clients.
46 ********************************************************************/
48 uint64_t smb_roundup(connection_struct
*conn
, uint64_t val
)
50 uint64_t rval
= lp_allocation_roundup_size(SNUM(conn
));
52 /* Only roundup for Windows clients. */
53 enum remote_arch_types ra_type
= get_remote_arch();
54 if (rval
&& (ra_type
!= RA_SAMBA
) && (ra_type
!= RA_CIFSFS
)) {
55 val
= SMB_ROUNDUP(val
,rval
);
60 /****************************************************************************
61 Utility functions for dealing with extended attributes.
62 ****************************************************************************/
64 /****************************************************************************
65 Refuse to allow clients to overwrite our private xattrs.
66 ****************************************************************************/
68 static bool samba_private_attr_name(const char *unix_ea_name
)
70 static const char * const prohibited_ea_names
[] = {
71 SAMBA_POSIX_INHERITANCE_EA_NAME
,
72 SAMBA_XATTR_DOS_ATTRIB
,
80 for (i
= 0; prohibited_ea_names
[i
]; i
++) {
81 if (strequal( prohibited_ea_names
[i
], unix_ea_name
))
84 if (StrnCaseCmp(unix_ea_name
, SAMBA_XATTR_DOSSTREAM_PREFIX
,
85 strlen(SAMBA_XATTR_DOSSTREAM_PREFIX
)) == 0) {
91 /****************************************************************************
92 Get one EA value. Fill in a struct ea_struct.
93 ****************************************************************************/
95 NTSTATUS
get_ea_value(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
,
96 files_struct
*fsp
, const char *fname
,
97 const char *ea_name
, struct ea_struct
*pea
)
99 /* Get the value of this xattr. Max size is 64k. */
100 size_t attr_size
= 256;
106 val
= TALLOC_REALLOC_ARRAY(mem_ctx
, val
, char, attr_size
);
108 return NT_STATUS_NO_MEMORY
;
111 if (fsp
&& fsp
->fh
->fd
!= -1) {
112 sizeret
= SMB_VFS_FGETXATTR(fsp
, ea_name
, val
, attr_size
);
114 sizeret
= SMB_VFS_GETXATTR(conn
, fname
, ea_name
, val
, attr_size
);
117 if (sizeret
== -1 && errno
== ERANGE
&& attr_size
!= 65536) {
123 return map_nt_error_from_unix(errno
);
126 DEBUG(10,("get_ea_value: EA %s is of length %u\n", ea_name
, (unsigned int)sizeret
));
127 dump_data(10, (uint8
*)val
, sizeret
);
130 if (strnequal(ea_name
, "user.", 5)) {
131 pea
->name
= talloc_strdup(mem_ctx
, &ea_name
[5]);
133 pea
->name
= talloc_strdup(mem_ctx
, ea_name
);
135 if (pea
->name
== NULL
) {
137 return NT_STATUS_NO_MEMORY
;
139 pea
->value
.data
= (unsigned char *)val
;
140 pea
->value
.length
= (size_t)sizeret
;
144 NTSTATUS
get_ea_names_from_file(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
,
145 files_struct
*fsp
, const char *fname
,
146 char ***pnames
, size_t *pnum_names
)
148 /* Get a list of all xattrs. Max namesize is 64k. */
149 size_t ea_namelist_size
= 1024;
150 char *ea_namelist
= NULL
;
155 ssize_t sizeret
= -1;
157 if (!lp_ea_support(SNUM(conn
))) {
166 * TALLOC the result early to get the talloc hierarchy right.
169 names
= TALLOC_ARRAY(mem_ctx
, char *, 1);
171 DEBUG(0, ("talloc failed\n"));
172 return NT_STATUS_NO_MEMORY
;
175 while (ea_namelist_size
<= 65536) {
177 ea_namelist
= TALLOC_REALLOC_ARRAY(
178 names
, ea_namelist
, char, ea_namelist_size
);
179 if (ea_namelist
== NULL
) {
180 DEBUG(0, ("talloc failed\n"));
182 return NT_STATUS_NO_MEMORY
;
185 if (fsp
&& fsp
->fh
->fd
!= -1) {
186 sizeret
= SMB_VFS_FLISTXATTR(fsp
, ea_namelist
,
189 sizeret
= SMB_VFS_LISTXATTR(conn
, fname
, ea_namelist
,
193 if ((sizeret
== -1) && (errno
== ERANGE
)) {
194 ea_namelist_size
*= 2;
203 return map_nt_error_from_unix(errno
);
206 DEBUG(10, ("get_ea_list_from_file: ea_namelist size = %u\n",
207 (unsigned int)sizeret
));
219 * Ensure the result is 0-terminated
222 if (ea_namelist
[sizeret
-1] != '\0') {
224 return NT_STATUS_INTERNAL_ERROR
;
232 for (p
= ea_namelist
; p
- ea_namelist
< sizeret
; p
+= strlen(p
)+1) {
236 tmp
= TALLOC_REALLOC_ARRAY(mem_ctx
, names
, char *, num_names
);
238 DEBUG(0, ("talloc failed\n"));
240 return NT_STATUS_NO_MEMORY
;
246 for (p
= ea_namelist
; p
- ea_namelist
< sizeret
; p
+= strlen(p
)+1) {
247 names
[num_names
++] = p
;
255 *pnum_names
= num_names
;
259 /****************************************************************************
260 Return a linked list of the total EA's. Plus the total size
261 ****************************************************************************/
263 static struct ea_list
*get_ea_list_from_file(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
, files_struct
*fsp
,
264 const char *fname
, size_t *pea_total_len
)
266 /* Get a list of all xattrs. Max namesize is 64k. */
269 struct ea_list
*ea_list_head
= NULL
;
274 if (!lp_ea_support(SNUM(conn
))) {
278 status
= get_ea_names_from_file(talloc_tos(), conn
, fsp
, fname
,
281 if (!NT_STATUS_IS_OK(status
) || (num_names
== 0)) {
285 for (i
=0; i
<num_names
; i
++) {
286 struct ea_list
*listp
;
289 if (strnequal(names
[i
], "system.", 7)
290 || samba_private_attr_name(names
[i
]))
293 listp
= TALLOC_P(mem_ctx
, struct ea_list
);
298 if (!NT_STATUS_IS_OK(get_ea_value(mem_ctx
, conn
, fsp
,
304 push_ascii_fstring(dos_ea_name
, listp
->ea
.name
);
307 4 + strlen(dos_ea_name
) + 1 + listp
->ea
.value
.length
;
309 DEBUG(10,("get_ea_list_from_file: total_len = %u, %s, val len "
310 "= %u\n", (unsigned int)*pea_total_len
, dos_ea_name
,
311 (unsigned int)listp
->ea
.value
.length
));
313 DLIST_ADD_END(ea_list_head
, listp
, struct ea_list
*);
317 /* Add on 4 for total length. */
318 if (*pea_total_len
) {
322 DEBUG(10, ("get_ea_list_from_file: total_len = %u\n",
323 (unsigned int)*pea_total_len
));
328 /****************************************************************************
329 Fill a qfilepathinfo buffer with EA's. Returns the length of the buffer
331 ****************************************************************************/
333 static unsigned int fill_ea_buffer(TALLOC_CTX
*mem_ctx
, char *pdata
, unsigned int total_data_size
,
334 connection_struct
*conn
, struct ea_list
*ea_list
)
336 unsigned int ret_data_size
= 4;
339 SMB_ASSERT(total_data_size
>= 4);
341 if (!lp_ea_support(SNUM(conn
))) {
346 for (p
= pdata
+ 4; ea_list
; ea_list
= ea_list
->next
) {
349 push_ascii_fstring(dos_ea_name
, ea_list
->ea
.name
);
350 dos_namelen
= strlen(dos_ea_name
);
351 if (dos_namelen
> 255 || dos_namelen
== 0) {
354 if (ea_list
->ea
.value
.length
> 65535) {
357 if (4 + dos_namelen
+ 1 + ea_list
->ea
.value
.length
> total_data_size
) {
361 /* We know we have room. */
362 SCVAL(p
,0,ea_list
->ea
.flags
);
363 SCVAL(p
,1,dos_namelen
);
364 SSVAL(p
,2,ea_list
->ea
.value
.length
);
365 fstrcpy(p
+4, dos_ea_name
);
366 memcpy( p
+ 4 + dos_namelen
+ 1, ea_list
->ea
.value
.data
, ea_list
->ea
.value
.length
);
368 total_data_size
-= 4 + dos_namelen
+ 1 + ea_list
->ea
.value
.length
;
369 p
+= 4 + dos_namelen
+ 1 + ea_list
->ea
.value
.length
;
372 ret_data_size
= PTR_DIFF(p
, pdata
);
373 DEBUG(10,("fill_ea_buffer: data_size = %u\n", ret_data_size
));
374 SIVAL(pdata
,0,ret_data_size
);
375 return ret_data_size
;
378 static NTSTATUS
fill_ea_chained_buffer(TALLOC_CTX
*mem_ctx
,
380 unsigned int total_data_size
,
381 unsigned int *ret_data_size
,
382 connection_struct
*conn
,
383 struct ea_list
*ea_list
)
385 uint8_t *p
= (uint8_t *)pdata
;
386 uint8_t *last_start
= NULL
;
390 if (!lp_ea_support(SNUM(conn
))) {
391 return NT_STATUS_NO_EAS_ON_FILE
;
394 for (; ea_list
; ea_list
= ea_list
->next
) {
400 SIVAL(last_start
, 0, PTR_DIFF(p
, last_start
));
404 push_ascii_fstring(dos_ea_name
, ea_list
->ea
.name
);
405 dos_namelen
= strlen(dos_ea_name
);
406 if (dos_namelen
> 255 || dos_namelen
== 0) {
407 return NT_STATUS_INTERNAL_ERROR
;
409 if (ea_list
->ea
.value
.length
> 65535) {
410 return NT_STATUS_INTERNAL_ERROR
;
413 this_size
= 0x08 + dos_namelen
+ 1 + ea_list
->ea
.value
.length
;
416 size_t pad
= 4 - (this_size
% 4);
420 if (this_size
> total_data_size
) {
421 return NT_STATUS_INFO_LENGTH_MISMATCH
;
424 /* We know we have room. */
425 SIVAL(p
, 0x00, 0); /* next offset */
426 SCVAL(p
, 0x04, ea_list
->ea
.flags
);
427 SCVAL(p
, 0x05, dos_namelen
);
428 SSVAL(p
, 0x06, ea_list
->ea
.value
.length
);
429 fstrcpy((char *)(p
+0x08), dos_ea_name
);
430 memcpy(p
+ 0x08 + dos_namelen
+ 1, ea_list
->ea
.value
.data
, ea_list
->ea
.value
.length
);
432 total_data_size
-= this_size
;
436 *ret_data_size
= PTR_DIFF(p
, pdata
);
437 DEBUG(10,("fill_ea_chained_buffer: data_size = %u\n", *ret_data_size
));
441 static unsigned int estimate_ea_size(connection_struct
*conn
, files_struct
*fsp
, const char *fname
)
443 size_t total_ea_len
= 0;
444 TALLOC_CTX
*mem_ctx
= NULL
;
446 if (!lp_ea_support(SNUM(conn
))) {
449 mem_ctx
= talloc_tos();
450 (void)get_ea_list_from_file(mem_ctx
, conn
, fsp
, fname
, &total_ea_len
);
454 /****************************************************************************
455 Ensure the EA name is case insensitive by matching any existing EA name.
456 ****************************************************************************/
458 static void canonicalize_ea_name(connection_struct
*conn
, files_struct
*fsp
, const char *fname
, fstring unix_ea_name
)
461 TALLOC_CTX
*mem_ctx
= talloc_tos();
462 struct ea_list
*ea_list
= get_ea_list_from_file(mem_ctx
, conn
, fsp
, fname
, &total_ea_len
);
464 for (; ea_list
; ea_list
= ea_list
->next
) {
465 if (strequal(&unix_ea_name
[5], ea_list
->ea
.name
)) {
466 DEBUG(10,("canonicalize_ea_name: %s -> %s\n",
467 &unix_ea_name
[5], ea_list
->ea
.name
));
468 safe_strcpy(&unix_ea_name
[5], ea_list
->ea
.name
, sizeof(fstring
)-6);
474 /****************************************************************************
475 Set or delete an extended attribute.
476 ****************************************************************************/
478 NTSTATUS
set_ea(connection_struct
*conn
, files_struct
*fsp
,
479 const struct smb_filename
*smb_fname
, struct ea_list
*ea_list
)
483 if (!lp_ea_support(SNUM(conn
))) {
484 return NT_STATUS_EAS_NOT_SUPPORTED
;
487 /* For now setting EAs on streams isn't supported. */
488 fname
= smb_fname
->base_name
;
490 for (;ea_list
; ea_list
= ea_list
->next
) {
492 fstring unix_ea_name
;
494 fstrcpy(unix_ea_name
, "user."); /* All EA's must start with user. */
495 fstrcat(unix_ea_name
, ea_list
->ea
.name
);
497 canonicalize_ea_name(conn
, fsp
, fname
, unix_ea_name
);
499 DEBUG(10,("set_ea: ea_name %s ealen = %u\n", unix_ea_name
, (unsigned int)ea_list
->ea
.value
.length
));
501 if (samba_private_attr_name(unix_ea_name
)) {
502 DEBUG(10,("set_ea: ea name %s is a private Samba name.\n", unix_ea_name
));
503 return NT_STATUS_ACCESS_DENIED
;
506 if (ea_list
->ea
.value
.length
== 0) {
507 /* Remove the attribute. */
508 if (fsp
&& (fsp
->fh
->fd
!= -1)) {
509 DEBUG(10,("set_ea: deleting ea name %s on "
510 "file %s by file descriptor.\n",
511 unix_ea_name
, fsp_str_dbg(fsp
)));
512 ret
= SMB_VFS_FREMOVEXATTR(fsp
, unix_ea_name
);
514 DEBUG(10,("set_ea: deleting ea name %s on file %s.\n",
515 unix_ea_name
, fname
));
516 ret
= SMB_VFS_REMOVEXATTR(conn
, fname
, unix_ea_name
);
519 /* Removing a non existent attribute always succeeds. */
520 if (ret
== -1 && errno
== ENOATTR
) {
521 DEBUG(10,("set_ea: deleting ea name %s didn't exist - succeeding by default.\n",
527 if (fsp
&& (fsp
->fh
->fd
!= -1)) {
528 DEBUG(10,("set_ea: setting ea name %s on file "
529 "%s by file descriptor.\n",
530 unix_ea_name
, fsp_str_dbg(fsp
)));
531 ret
= SMB_VFS_FSETXATTR(fsp
, unix_ea_name
,
532 ea_list
->ea
.value
.data
, ea_list
->ea
.value
.length
, 0);
534 DEBUG(10,("set_ea: setting ea name %s on file %s.\n",
535 unix_ea_name
, fname
));
536 ret
= SMB_VFS_SETXATTR(conn
, fname
, unix_ea_name
,
537 ea_list
->ea
.value
.data
, ea_list
->ea
.value
.length
, 0);
543 if (errno
== ENOTSUP
) {
544 return NT_STATUS_EAS_NOT_SUPPORTED
;
547 return map_nt_error_from_unix(errno
);
553 /****************************************************************************
554 Read a list of EA names from an incoming data buffer. Create an ea_list with them.
555 ****************************************************************************/
557 static struct ea_list
*read_ea_name_list(TALLOC_CTX
*ctx
, const char *pdata
, size_t data_size
)
559 struct ea_list
*ea_list_head
= NULL
;
560 size_t converted_size
, offset
= 0;
562 while (offset
+ 2 < data_size
) {
563 struct ea_list
*eal
= TALLOC_ZERO_P(ctx
, struct ea_list
);
564 unsigned int namelen
= CVAL(pdata
,offset
);
566 offset
++; /* Go past the namelen byte. */
568 /* integer wrap paranioa. */
569 if ((offset
+ namelen
< offset
) || (offset
+ namelen
< namelen
) ||
570 (offset
> data_size
) || (namelen
> data_size
) ||
571 (offset
+ namelen
>= data_size
)) {
574 /* Ensure the name is null terminated. */
575 if (pdata
[offset
+ namelen
] != '\0') {
578 if (!pull_ascii_talloc(ctx
, &eal
->ea
.name
, &pdata
[offset
],
580 DEBUG(0,("read_ea_name_list: pull_ascii_talloc "
581 "failed: %s", strerror(errno
)));
587 offset
+= (namelen
+ 1); /* Go past the name + terminating zero. */
588 DLIST_ADD_END(ea_list_head
, eal
, struct ea_list
*);
589 DEBUG(10,("read_ea_name_list: read ea name %s\n", eal
->ea
.name
));
595 /****************************************************************************
596 Read one EA list entry from the buffer.
597 ****************************************************************************/
599 struct ea_list
*read_ea_list_entry(TALLOC_CTX
*ctx
, const char *pdata
, size_t data_size
, size_t *pbytes_used
)
601 struct ea_list
*eal
= TALLOC_ZERO_P(ctx
, struct ea_list
);
603 unsigned int namelen
;
604 size_t converted_size
;
614 eal
->ea
.flags
= CVAL(pdata
,0);
615 namelen
= CVAL(pdata
,1);
616 val_len
= SVAL(pdata
,2);
618 if (4 + namelen
+ 1 + val_len
> data_size
) {
622 /* Ensure the name is null terminated. */
623 if (pdata
[namelen
+ 4] != '\0') {
626 if (!pull_ascii_talloc(ctx
, &eal
->ea
.name
, pdata
+ 4, &converted_size
)) {
627 DEBUG(0,("read_ea_list_entry: pull_ascii_talloc failed: %s",
634 eal
->ea
.value
= data_blob_talloc(eal
, NULL
, (size_t)val_len
+ 1);
635 if (!eal
->ea
.value
.data
) {
639 memcpy(eal
->ea
.value
.data
, pdata
+ 4 + namelen
+ 1, val_len
);
641 /* Ensure we're null terminated just in case we print the value. */
642 eal
->ea
.value
.data
[val_len
] = '\0';
643 /* But don't count the null. */
644 eal
->ea
.value
.length
--;
647 *pbytes_used
= 4 + namelen
+ 1 + val_len
;
650 DEBUG(10,("read_ea_list_entry: read ea name %s\n", eal
->ea
.name
));
651 dump_data(10, eal
->ea
.value
.data
, eal
->ea
.value
.length
);
656 /****************************************************************************
657 Read a list of EA names and data from an incoming data buffer. Create an ea_list with them.
658 ****************************************************************************/
660 static struct ea_list
*read_ea_list(TALLOC_CTX
*ctx
, const char *pdata
, size_t data_size
)
662 struct ea_list
*ea_list_head
= NULL
;
664 size_t bytes_used
= 0;
666 while (offset
< data_size
) {
667 struct ea_list
*eal
= read_ea_list_entry(ctx
, pdata
+ offset
, data_size
- offset
, &bytes_used
);
673 DLIST_ADD_END(ea_list_head
, eal
, struct ea_list
*);
674 offset
+= bytes_used
;
680 /****************************************************************************
681 Count the total EA size needed.
682 ****************************************************************************/
684 static size_t ea_list_size(struct ea_list
*ealist
)
687 struct ea_list
*listp
;
690 for (listp
= ealist
; listp
; listp
= listp
->next
) {
691 push_ascii_fstring(dos_ea_name
, listp
->ea
.name
);
692 ret
+= 4 + strlen(dos_ea_name
) + 1 + listp
->ea
.value
.length
;
694 /* Add on 4 for total length. */
702 /****************************************************************************
703 Return a union of EA's from a file list and a list of names.
704 The TALLOC context for the two lists *MUST* be identical as we steal
705 memory from one list to add to another. JRA.
706 ****************************************************************************/
708 static struct ea_list
*ea_list_union(struct ea_list
*name_list
, struct ea_list
*file_list
, size_t *total_ea_len
)
710 struct ea_list
*nlistp
, *flistp
;
712 for (nlistp
= name_list
; nlistp
; nlistp
= nlistp
->next
) {
713 for (flistp
= file_list
; flistp
; flistp
= flistp
->next
) {
714 if (strequal(nlistp
->ea
.name
, flistp
->ea
.name
)) {
720 /* Copy the data from this entry. */
721 nlistp
->ea
.flags
= flistp
->ea
.flags
;
722 nlistp
->ea
.value
= flistp
->ea
.value
;
725 nlistp
->ea
.flags
= 0;
726 ZERO_STRUCT(nlistp
->ea
.value
);
730 *total_ea_len
= ea_list_size(name_list
);
734 /****************************************************************************
735 Send the required number of replies back.
736 We assume all fields other than the data fields are
737 set correctly for the type of call.
738 HACK ! Always assumes smb_setup field is zero.
739 ****************************************************************************/
741 void send_trans2_replies(connection_struct
*conn
,
742 struct smb_request
*req
,
749 /* As we are using a protocol > LANMAN1 then the max_send
750 variable must have been set in the sessetupX call.
751 This takes precedence over the max_xmit field in the
752 global struct. These different max_xmit variables should
753 be merged as this is now too confusing */
755 int data_to_send
= datasize
;
756 int params_to_send
= paramsize
;
758 const char *pp
= params
;
759 const char *pd
= pdata
;
760 int params_sent_thistime
, data_sent_thistime
, total_sent_thistime
;
761 int alignment_offset
= 1; /* JRA. This used to be 3. Set to 1 to make netmon parse ok. */
762 int data_alignment_offset
= 0;
763 bool overflow
= False
;
764 struct smbd_server_connection
*sconn
= smbd_server_conn
;
765 int max_send
= sconn
->smb1
.sessions
.max_send
;
767 /* Modify the data_to_send and datasize and set the error if
768 we're trying to send more than max_data_bytes. We still send
769 the part of the packet(s) that fit. Strange, but needed
772 if (max_data_bytes
> 0 && datasize
> max_data_bytes
) {
773 DEBUG(5,("send_trans2_replies: max_data_bytes %d exceeded by data %d\n",
774 max_data_bytes
, datasize
));
775 datasize
= data_to_send
= max_data_bytes
;
779 /* If there genuinely are no parameters or data to send just send the empty packet */
781 if(params_to_send
== 0 && data_to_send
== 0) {
782 reply_outbuf(req
, 10, 0);
783 show_msg((char *)req
->outbuf
);
784 if (!srv_send_smb(smbd_server_fd(),
787 IS_CONN_ENCRYPTED(conn
),
789 exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
791 TALLOC_FREE(req
->outbuf
);
795 /* When sending params and data ensure that both are nicely aligned */
796 /* Only do this alignment when there is also data to send - else
797 can cause NT redirector problems. */
799 if (((params_to_send
% 4) != 0) && (data_to_send
!= 0))
800 data_alignment_offset
= 4 - (params_to_send
% 4);
802 /* Space is bufsize minus Netbios over TCP header minus SMB header */
803 /* The alignment_offset is to align the param bytes on an even byte
804 boundary. NT 4.0 Beta needs this to work correctly. */
806 useable_space
= max_send
- (smb_size
809 + data_alignment_offset
);
811 if (useable_space
< 0) {
812 DEBUG(0, ("send_trans2_replies failed sanity useable_space "
813 "= %d!!!", useable_space
));
814 exit_server_cleanly("send_trans2_replies: Not enough space");
817 while (params_to_send
|| data_to_send
) {
818 /* Calculate whether we will totally or partially fill this packet */
820 total_sent_thistime
= params_to_send
+ data_to_send
;
822 /* We can never send more than useable_space */
824 * Note that 'useable_space' does not include the alignment offsets,
825 * but we must include the alignment offsets in the calculation of
826 * the length of the data we send over the wire, as the alignment offsets
827 * are sent here. Fix from Marc_Jacobsen@hp.com.
830 total_sent_thistime
= MIN(total_sent_thistime
, useable_space
);
832 reply_outbuf(req
, 10, total_sent_thistime
+ alignment_offset
833 + data_alignment_offset
);
836 * We might have SMBtrans2s in req which was transferred to
837 * the outbuf, fix that.
839 SCVAL(req
->outbuf
, smb_com
, SMBtrans2
);
841 /* Set total params and data to be sent */
842 SSVAL(req
->outbuf
,smb_tprcnt
,paramsize
);
843 SSVAL(req
->outbuf
,smb_tdrcnt
,datasize
);
845 /* Calculate how many parameters and data we can fit into
846 * this packet. Parameters get precedence
849 params_sent_thistime
= MIN(params_to_send
,useable_space
);
850 data_sent_thistime
= useable_space
- params_sent_thistime
;
851 data_sent_thistime
= MIN(data_sent_thistime
,data_to_send
);
853 SSVAL(req
->outbuf
,smb_prcnt
, params_sent_thistime
);
855 /* smb_proff is the offset from the start of the SMB header to the
856 parameter bytes, however the first 4 bytes of outbuf are
857 the Netbios over TCP header. Thus use smb_base() to subtract
858 them from the calculation */
860 SSVAL(req
->outbuf
,smb_proff
,
861 ((smb_buf(req
->outbuf
)+alignment_offset
)
862 - smb_base(req
->outbuf
)));
864 if(params_sent_thistime
== 0)
865 SSVAL(req
->outbuf
,smb_prdisp
,0);
867 /* Absolute displacement of param bytes sent in this packet */
868 SSVAL(req
->outbuf
,smb_prdisp
,pp
- params
);
870 SSVAL(req
->outbuf
,smb_drcnt
, data_sent_thistime
);
871 if(data_sent_thistime
== 0) {
872 SSVAL(req
->outbuf
,smb_droff
,0);
873 SSVAL(req
->outbuf
,smb_drdisp
, 0);
875 /* The offset of the data bytes is the offset of the
876 parameter bytes plus the number of parameters being sent this time */
877 SSVAL(req
->outbuf
, smb_droff
,
878 ((smb_buf(req
->outbuf
)+alignment_offset
)
879 - smb_base(req
->outbuf
))
880 + params_sent_thistime
+ data_alignment_offset
);
881 SSVAL(req
->outbuf
,smb_drdisp
, pd
- pdata
);
884 /* Initialize the padding for alignment */
886 if (alignment_offset
!= 0) {
887 memset(smb_buf(req
->outbuf
), 0, alignment_offset
);
890 /* Copy the param bytes into the packet */
892 if(params_sent_thistime
) {
893 memcpy((smb_buf(req
->outbuf
)+alignment_offset
), pp
,
894 params_sent_thistime
);
897 /* Copy in the data bytes */
898 if(data_sent_thistime
) {
899 if (data_alignment_offset
!= 0) {
900 memset((smb_buf(req
->outbuf
)+alignment_offset
+
901 params_sent_thistime
), 0,
902 data_alignment_offset
);
904 memcpy(smb_buf(req
->outbuf
)+alignment_offset
905 +params_sent_thistime
+data_alignment_offset
,
906 pd
,data_sent_thistime
);
909 DEBUG(9,("t2_rep: params_sent_thistime = %d, data_sent_thistime = %d, useable_space = %d\n",
910 params_sent_thistime
, data_sent_thistime
, useable_space
));
911 DEBUG(9,("t2_rep: params_to_send = %d, data_to_send = %d, paramsize = %d, datasize = %d\n",
912 params_to_send
, data_to_send
, paramsize
, datasize
));
915 error_packet_set((char *)req
->outbuf
,
916 ERRDOS
,ERRbufferoverflow
,
917 STATUS_BUFFER_OVERFLOW
,
921 /* Send the packet */
922 show_msg((char *)req
->outbuf
);
923 if (!srv_send_smb(smbd_server_fd(),
926 IS_CONN_ENCRYPTED(conn
),
928 exit_server_cleanly("send_trans2_replies: srv_send_smb failed.");
930 TALLOC_FREE(req
->outbuf
);
932 pp
+= params_sent_thistime
;
933 pd
+= data_sent_thistime
;
935 params_to_send
-= params_sent_thistime
;
936 data_to_send
-= data_sent_thistime
;
939 if(params_to_send
< 0 || data_to_send
< 0) {
940 DEBUG(0,("send_trans2_replies failed sanity check pts = %d, dts = %d\n!!!",
941 params_to_send
, data_to_send
));
949 /****************************************************************************
950 Reply to a TRANSACT2_OPEN.
951 ****************************************************************************/
953 static void call_trans2open(connection_struct
*conn
,
954 struct smb_request
*req
,
955 char **pparams
, int total_params
,
956 char **ppdata
, int total_data
,
957 unsigned int max_data_bytes
)
959 struct smb_filename
*smb_fname
= NULL
;
960 char *params
= *pparams
;
961 char *pdata
= *ppdata
;
966 bool return_additional_info
;
979 struct ea_list
*ea_list
= NULL
;
984 uint32 create_disposition
;
985 uint32 create_options
= 0;
986 uint32_t private_flags
= 0;
987 TALLOC_CTX
*ctx
= talloc_tos();
990 * Ensure we have enough parameters to perform the operation.
993 if (total_params
< 29) {
994 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
998 flags
= SVAL(params
, 0);
999 deny_mode
= SVAL(params
, 2);
1000 open_attr
= SVAL(params
,6);
1001 oplock_request
= (flags
& REQUEST_OPLOCK
) ? EXCLUSIVE_OPLOCK
: 0;
1002 if (oplock_request
) {
1003 oplock_request
|= (flags
& REQUEST_BATCH_OPLOCK
) ? BATCH_OPLOCK
: 0;
1007 return_additional_info
= BITSETW(params
,0);
1008 open_sattr
= SVAL(params
, 4);
1009 open_time
= make_unix_date3(params
+8);
1011 open_ofun
= SVAL(params
,12);
1012 open_size
= IVAL(params
,14);
1013 pname
= ¶ms
[28];
1016 reply_nterror(req
, NT_STATUS_NETWORK_ACCESS_DENIED
);
1020 srvstr_get_path(ctx
, params
, req
->flags2
, &fname
, pname
,
1021 total_params
- 28, STR_TERMINATE
,
1023 if (!NT_STATUS_IS_OK(status
)) {
1024 reply_nterror(req
, status
);
1028 DEBUG(3,("call_trans2open %s deny_mode=0x%x attr=%d ofun=0x%x size=%d\n",
1029 fname
, (unsigned int)deny_mode
, (unsigned int)open_attr
,
1030 (unsigned int)open_ofun
, open_size
));
1032 status
= filename_convert(ctx
,
1034 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
1039 if (!NT_STATUS_IS_OK(status
)) {
1040 if (NT_STATUS_EQUAL(status
,NT_STATUS_PATH_NOT_COVERED
)) {
1041 reply_botherror(req
,
1042 NT_STATUS_PATH_NOT_COVERED
,
1043 ERRSRV
, ERRbadpath
);
1046 reply_nterror(req
, status
);
1050 if (open_ofun
== 0) {
1051 reply_nterror(req
, NT_STATUS_OBJECT_NAME_COLLISION
);
1055 if (!map_open_params_to_ntcreate(smb_fname
, deny_mode
, open_ofun
,
1056 &access_mask
, &share_mode
,
1057 &create_disposition
,
1060 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
1064 /* Any data in this call is an EA list. */
1065 if (total_data
&& (total_data
!= 4)) {
1066 if (total_data
< 10) {
1067 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
1071 if (IVAL(pdata
,0) > total_data
) {
1072 DEBUG(10,("call_trans2open: bad total data size (%u) > %u\n",
1073 IVAL(pdata
,0), (unsigned int)total_data
));
1074 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
1078 ea_list
= read_ea_list(talloc_tos(), pdata
+ 4,
1081 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
1085 if (!lp_ea_support(SNUM(conn
))) {
1086 reply_nterror(req
, NT_STATUS_EAS_NOT_SUPPORTED
);
1091 status
= SMB_VFS_CREATE_FILE(
1094 0, /* root_dir_fid */
1095 smb_fname
, /* fname */
1096 access_mask
, /* access_mask */
1097 share_mode
, /* share_access */
1098 create_disposition
, /* create_disposition*/
1099 create_options
, /* create_options */
1100 open_attr
, /* file_attributes */
1101 oplock_request
, /* oplock_request */
1102 open_size
, /* allocation_size */
1105 ea_list
, /* ea_list */
1107 &smb_action
); /* psbuf */
1109 if (!NT_STATUS_IS_OK(status
)) {
1110 if (open_was_deferred(req
->mid
)) {
1111 /* We have re-scheduled this call. */
1114 reply_openerror(req
, status
);
1118 size
= get_file_size_stat(&smb_fname
->st
);
1119 fattr
= dos_mode(conn
, smb_fname
);
1120 mtime
= convert_timespec_to_time_t(smb_fname
->st
.st_ex_mtime
);
1121 inode
= smb_fname
->st
.st_ex_ino
;
1123 close_file(req
, fsp
, ERROR_CLOSE
);
1124 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
1128 /* Realloc the size of parameters and data we will return */
1129 *pparams
= (char *)SMB_REALLOC(*pparams
, 30);
1130 if(*pparams
== NULL
) {
1131 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
1136 SSVAL(params
,0,fsp
->fnum
);
1137 SSVAL(params
,2,fattr
);
1138 srv_put_dos_date2(params
,4, mtime
);
1139 SIVAL(params
,8, (uint32
)size
);
1140 SSVAL(params
,12,deny_mode
);
1141 SSVAL(params
,14,0); /* open_type - file or directory. */
1142 SSVAL(params
,16,0); /* open_state - only valid for IPC device. */
1144 if (oplock_request
&& lp_fake_oplocks(SNUM(conn
))) {
1145 smb_action
|= EXTENDED_OPLOCK_GRANTED
;
1148 SSVAL(params
,18,smb_action
);
1151 * WARNING - this may need to be changed if SMB_INO_T <> 4 bytes.
1153 SIVAL(params
,20,inode
);
1154 SSVAL(params
,24,0); /* Padding. */
1156 uint32 ea_size
= estimate_ea_size(conn
, fsp
,
1157 fsp
->fsp_name
->base_name
);
1158 SIVAL(params
, 26, ea_size
);
1160 SIVAL(params
, 26, 0);
1163 /* Send the required number of replies */
1164 send_trans2_replies(conn
, req
, params
, 30, *ppdata
, 0, max_data_bytes
);
1166 TALLOC_FREE(smb_fname
);
1169 /*********************************************************
1170 Routine to check if a given string matches exactly.
1171 as a special case a mask of "." does NOT match. That
1172 is required for correct wildcard semantics
1173 Case can be significant or not.
1174 **********************************************************/
1176 static bool exact_match(bool has_wild
,
1177 bool case_sensitive
,
1181 if (mask
[0] == '.' && mask
[1] == 0) {
1189 if (case_sensitive
) {
1190 return strcmp(str
,mask
)==0;
1192 return StrCaseCmp(str
,mask
) == 0;
1196 /****************************************************************************
1197 Return the filetype for UNIX extensions.
1198 ****************************************************************************/
1200 static uint32
unix_filetype(mode_t mode
)
1203 return UNIX_TYPE_FILE
;
1204 else if(S_ISDIR(mode
))
1205 return UNIX_TYPE_DIR
;
1207 else if(S_ISLNK(mode
))
1208 return UNIX_TYPE_SYMLINK
;
1211 else if(S_ISCHR(mode
))
1212 return UNIX_TYPE_CHARDEV
;
1215 else if(S_ISBLK(mode
))
1216 return UNIX_TYPE_BLKDEV
;
1219 else if(S_ISFIFO(mode
))
1220 return UNIX_TYPE_FIFO
;
1223 else if(S_ISSOCK(mode
))
1224 return UNIX_TYPE_SOCKET
;
1227 DEBUG(0,("unix_filetype: unknown filetype %u\n", (unsigned)mode
));
1228 return UNIX_TYPE_UNKNOWN
;
1231 /****************************************************************************
1232 Map wire perms onto standard UNIX permissions. Obey share restrictions.
1233 ****************************************************************************/
1235 enum perm_type
{ PERM_NEW_FILE
, PERM_NEW_DIR
, PERM_EXISTING_FILE
, PERM_EXISTING_DIR
};
1237 static NTSTATUS
unix_perms_from_wire( connection_struct
*conn
,
1238 const SMB_STRUCT_STAT
*psbuf
,
1240 enum perm_type ptype
,
1245 if (perms
== SMB_MODE_NO_CHANGE
) {
1246 if (!VALID_STAT(*psbuf
)) {
1247 return NT_STATUS_INVALID_PARAMETER
;
1249 *ret_perms
= psbuf
->st_ex_mode
;
1250 return NT_STATUS_OK
;
1254 ret
|= ((perms
& UNIX_X_OTH
) ? S_IXOTH
: 0);
1255 ret
|= ((perms
& UNIX_W_OTH
) ? S_IWOTH
: 0);
1256 ret
|= ((perms
& UNIX_R_OTH
) ? S_IROTH
: 0);
1257 ret
|= ((perms
& UNIX_X_GRP
) ? S_IXGRP
: 0);
1258 ret
|= ((perms
& UNIX_W_GRP
) ? S_IWGRP
: 0);
1259 ret
|= ((perms
& UNIX_R_GRP
) ? S_IRGRP
: 0);
1260 ret
|= ((perms
& UNIX_X_USR
) ? S_IXUSR
: 0);
1261 ret
|= ((perms
& UNIX_W_USR
) ? S_IWUSR
: 0);
1262 ret
|= ((perms
& UNIX_R_USR
) ? S_IRUSR
: 0);
1264 ret
|= ((perms
& UNIX_STICKY
) ? S_ISVTX
: 0);
1267 ret
|= ((perms
& UNIX_SET_GID
) ? S_ISGID
: 0);
1270 ret
|= ((perms
& UNIX_SET_UID
) ? S_ISUID
: 0);
1275 /* Apply mode mask */
1276 ret
&= lp_create_mask(SNUM(conn
));
1277 /* Add in force bits */
1278 ret
|= lp_force_create_mode(SNUM(conn
));
1281 ret
&= lp_dir_mask(SNUM(conn
));
1282 /* Add in force bits */
1283 ret
|= lp_force_dir_mode(SNUM(conn
));
1285 case PERM_EXISTING_FILE
:
1286 /* Apply mode mask */
1287 ret
&= lp_security_mask(SNUM(conn
));
1288 /* Add in force bits */
1289 ret
|= lp_force_security_mode(SNUM(conn
));
1291 case PERM_EXISTING_DIR
:
1292 /* Apply mode mask */
1293 ret
&= lp_dir_security_mask(SNUM(conn
));
1294 /* Add in force bits */
1295 ret
|= lp_force_dir_security_mode(SNUM(conn
));
1300 return NT_STATUS_OK
;
1303 /****************************************************************************
1304 Needed to show the msdfs symlinks as directories. Modifies psbuf
1305 to be a directory if it's a msdfs link.
1306 ****************************************************************************/
1308 static bool check_msdfs_link(connection_struct
*conn
,
1309 const char *pathname
,
1310 SMB_STRUCT_STAT
*psbuf
)
1312 int saved_errno
= errno
;
1313 if(lp_host_msdfs() &&
1314 lp_msdfs_root(SNUM(conn
)) &&
1315 is_msdfs_link(conn
, pathname
, psbuf
)) {
1317 DEBUG(5,("check_msdfs_link: Masquerading msdfs link %s "
1320 psbuf
->st_ex_mode
= (psbuf
->st_ex_mode
& 0xFFF) | S_IFDIR
;
1321 errno
= saved_errno
;
1324 errno
= saved_errno
;
1329 /****************************************************************************
1330 Get a level dependent lanman2 dir entry.
1331 ****************************************************************************/
1333 struct smbd_dirptr_lanman2_state
{
1334 connection_struct
*conn
;
1335 uint32_t info_level
;
1336 bool check_mangled_names
;
1338 bool got_exact_match
;
1341 static bool smbd_dirptr_lanman2_match_fn(TALLOC_CTX
*ctx
,
1347 struct smbd_dirptr_lanman2_state
*state
=
1348 (struct smbd_dirptr_lanman2_state
*)private_data
;
1350 char mangled_name
[13]; /* mangled 8.3 name. */
1354 /* Mangle fname if it's an illegal name. */
1355 if (mangle_must_mangle(dname
, state
->conn
->params
)) {
1356 ok
= name_to_8_3(dname
, mangled_name
,
1357 true, state
->conn
->params
);
1361 fname
= mangled_name
;
1366 got_match
= exact_match(state
->has_wild
,
1367 state
->conn
->case_sensitive
,
1369 state
->got_exact_match
= got_match
;
1371 got_match
= mask_match(fname
, mask
,
1372 state
->conn
->case_sensitive
);
1375 if(!got_match
&& state
->check_mangled_names
&&
1376 !mangle_is_8_3(fname
, false, state
->conn
->params
)) {
1378 * It turns out that NT matches wildcards against
1379 * both long *and* short names. This may explain some
1380 * of the wildcard wierdness from old DOS clients
1381 * that some people have been seeing.... JRA.
1383 /* Force the mangling into 8.3. */
1384 ok
= name_to_8_3(fname
, mangled_name
,
1385 false, state
->conn
->params
);
1390 got_match
= exact_match(state
->has_wild
,
1391 state
->conn
->case_sensitive
,
1392 mangled_name
, mask
);
1393 state
->got_exact_match
= got_match
;
1395 got_match
= mask_match(mangled_name
, mask
,
1396 state
->conn
->case_sensitive
);
1404 *_fname
= talloc_strdup(ctx
, fname
);
1405 if (*_fname
== NULL
) {
1412 static bool smbd_dirptr_lanman2_mode_fn(TALLOC_CTX
*ctx
,
1414 struct smb_filename
*smb_fname
,
1417 struct smbd_dirptr_lanman2_state
*state
=
1418 (struct smbd_dirptr_lanman2_state
*)private_data
;
1419 bool ms_dfs_link
= false;
1422 if (INFO_LEVEL_IS_UNIX(state
->info_level
)) {
1423 if (SMB_VFS_LSTAT(state
->conn
, smb_fname
) != 0) {
1424 DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1425 "Couldn't lstat [%s] (%s)\n",
1426 smb_fname_str_dbg(smb_fname
),
1430 } else if (!VALID_STAT(smb_fname
->st
) &&
1431 SMB_VFS_STAT(state
->conn
, smb_fname
) != 0) {
1432 /* Needed to show the msdfs symlinks as
1435 ms_dfs_link
= check_msdfs_link(state
->conn
,
1436 smb_fname
->base_name
,
1439 DEBUG(5,("smbd_dirptr_lanman2_mode_fn: "
1440 "Couldn't stat [%s] (%s)\n",
1441 smb_fname_str_dbg(smb_fname
),
1448 mode
= dos_mode_msdfs(state
->conn
, smb_fname
);
1450 mode
= dos_mode(state
->conn
, smb_fname
);
1457 static bool smbd_marshall_dir_entry(TALLOC_CTX
*ctx
,
1458 connection_struct
*conn
,
1460 uint32_t info_level
,
1461 struct ea_list
*name_list
,
1462 bool check_mangled_names
,
1463 bool requires_resume_key
,
1466 const struct smb_filename
*smb_fname
,
1467 uint64_t space_remaining
,
1474 uint64_t *last_entry_off
)
1476 char *p
, *q
, *pdata
= *ppdata
;
1478 uint64_t file_size
= 0;
1479 uint64_t allocation_size
= 0;
1481 struct timespec mdate_ts
, adate_ts
, cdate_ts
, create_date_ts
;
1482 time_t mdate
= (time_t)0, adate
= (time_t)0, create_date
= (time_t)0;
1483 time_t c_date
= (time_t)0;
1485 char *last_entry_ptr
;
1490 *out_of_space
= false;
1492 ZERO_STRUCT(mdate_ts
);
1493 ZERO_STRUCT(adate_ts
);
1494 ZERO_STRUCT(create_date_ts
);
1495 ZERO_STRUCT(cdate_ts
);
1497 if (!(mode
& aDIR
)) {
1498 file_size
= get_file_size_stat(&smb_fname
->st
);
1500 allocation_size
= SMB_VFS_GET_ALLOC_SIZE(conn
, NULL
, &smb_fname
->st
);
1502 mdate_ts
= smb_fname
->st
.st_ex_mtime
;
1503 adate_ts
= smb_fname
->st
.st_ex_atime
;
1504 create_date_ts
= get_create_timespec(conn
, NULL
, smb_fname
);
1505 cdate_ts
= get_change_timespec(conn
, NULL
, smb_fname
);
1507 if (lp_dos_filetime_resolution(SNUM(conn
))) {
1508 dos_filetime_timespec(&create_date_ts
);
1509 dos_filetime_timespec(&mdate_ts
);
1510 dos_filetime_timespec(&adate_ts
);
1511 dos_filetime_timespec(&cdate_ts
);
1514 create_date
= convert_timespec_to_time_t(create_date_ts
);
1515 mdate
= convert_timespec_to_time_t(mdate_ts
);
1516 adate
= convert_timespec_to_time_t(adate_ts
);
1517 c_date
= convert_timespec_to_time_t(cdate_ts
);
1519 /* align the record */
1520 off
= PTR_DIFF(pdata
, base_data
);
1521 pad
= (off
+ (align
-1)) & ~(align
-1);
1524 /* initialize padding to 0 */
1526 memset(pdata
, 0, pad
);
1528 space_remaining
-= pad
;
1537 switch (info_level
) {
1538 case SMB_FIND_INFO_STANDARD
:
1539 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_INFO_STANDARD\n"));
1540 if(requires_resume_key
) {
1544 srv_put_dos_date2(p
,0,create_date
);
1545 srv_put_dos_date2(p
,4,adate
);
1546 srv_put_dos_date2(p
,8,mdate
);
1547 SIVAL(p
,12,(uint32
)file_size
);
1548 SIVAL(p
,16,(uint32
)allocation_size
);
1552 if (flags2
& FLAGS2_UNICODE_STRINGS
) {
1553 p
+= ucs2_align(base_data
, p
, 0);
1555 len
= srvstr_push(base_data
, flags2
, p
,
1556 fname
, PTR_DIFF(end_data
, p
),
1558 if (flags2
& FLAGS2_UNICODE_STRINGS
) {
1560 SCVAL(nameptr
, -1, len
- 2);
1562 SCVAL(nameptr
, -1, 0);
1566 SCVAL(nameptr
, -1, len
- 1);
1568 SCVAL(nameptr
, -1, 0);
1574 case SMB_FIND_EA_SIZE
:
1575 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_SIZE\n"));
1576 if (requires_resume_key
) {
1580 srv_put_dos_date2(p
,0,create_date
);
1581 srv_put_dos_date2(p
,4,adate
);
1582 srv_put_dos_date2(p
,8,mdate
);
1583 SIVAL(p
,12,(uint32
)file_size
);
1584 SIVAL(p
,16,(uint32
)allocation_size
);
1587 unsigned int ea_size
= estimate_ea_size(conn
, NULL
,
1588 smb_fname
->base_name
);
1589 SIVAL(p
,22,ea_size
); /* Extended attributes */
1593 len
= srvstr_push(base_data
, flags2
,
1594 p
, fname
, PTR_DIFF(end_data
, p
),
1595 STR_TERMINATE
| STR_NOALIGN
);
1596 if (flags2
& FLAGS2_UNICODE_STRINGS
) {
1609 SCVAL(nameptr
,0,len
);
1611 SCVAL(p
,0,0); p
+= 1; /* Extra zero byte ? - why.. */
1614 case SMB_FIND_EA_LIST
:
1616 struct ea_list
*file_list
= NULL
;
1619 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_EA_LIST\n"));
1623 if (requires_resume_key
) {
1627 srv_put_dos_date2(p
,0,create_date
);
1628 srv_put_dos_date2(p
,4,adate
);
1629 srv_put_dos_date2(p
,8,mdate
);
1630 SIVAL(p
,12,(uint32
)file_size
);
1631 SIVAL(p
,16,(uint32
)allocation_size
);
1633 p
+= 22; /* p now points to the EA area. */
1635 file_list
= get_ea_list_from_file(ctx
, conn
, NULL
,
1636 smb_fname
->base_name
,
1638 name_list
= ea_list_union(name_list
, file_list
, &ea_len
);
1640 /* We need to determine if this entry will fit in the space available. */
1641 /* Max string size is 255 bytes. */
1642 if (PTR_DIFF(p
+ 255 + ea_len
,pdata
) > space_remaining
) {
1643 *out_of_space
= true;
1644 DEBUG(9,("smbd_marshall_dir_entry: out of space\n"));
1645 return False
; /* Not finished - just out of space */
1648 /* Push the ea_data followed by the name. */
1649 p
+= fill_ea_buffer(ctx
, p
, space_remaining
, conn
, name_list
);
1651 len
= srvstr_push(base_data
, flags2
,
1652 p
+ 1, fname
, PTR_DIFF(end_data
, p
+1),
1653 STR_TERMINATE
| STR_NOALIGN
);
1654 if (flags2
& FLAGS2_UNICODE_STRINGS
) {
1667 SCVAL(nameptr
,0,len
);
1669 SCVAL(p
,0,0); p
+= 1; /* Extra zero byte ? - why.. */
1673 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
1674 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_BOTH_DIRECTORY_INFO\n"));
1675 was_8_3
= mangle_is_8_3(fname
, True
, conn
->params
);
1677 SIVAL(p
,0,reskey
); p
+= 4;
1678 put_long_date_timespec(conn
->ts_res
,p
,create_date_ts
); p
+= 8;
1679 put_long_date_timespec(conn
->ts_res
,p
,adate_ts
); p
+= 8;
1680 put_long_date_timespec(conn
->ts_res
,p
,mdate_ts
); p
+= 8;
1681 put_long_date_timespec(conn
->ts_res
,p
,cdate_ts
); p
+= 8;
1682 SOFF_T(p
,0,file_size
); p
+= 8;
1683 SOFF_T(p
,0,allocation_size
); p
+= 8;
1684 SIVAL(p
,0,mode
); p
+= 4;
1685 q
= p
; p
+= 4; /* q is placeholder for name length. */
1687 unsigned int ea_size
= estimate_ea_size(conn
, NULL
,
1688 smb_fname
->base_name
);
1689 SIVAL(p
,0,ea_size
); /* Extended attributes */
1692 /* Clear the short name buffer. This is
1693 * IMPORTANT as not doing so will trigger
1694 * a Win2k client bug. JRA.
1696 if (!was_8_3
&& check_mangled_names
) {
1697 char mangled_name
[13]; /* mangled 8.3 name. */
1698 if (!name_to_8_3(fname
,mangled_name
,True
,
1700 /* Error - mangle failed ! */
1701 memset(mangled_name
,'\0',12);
1703 mangled_name
[12] = 0;
1704 len
= srvstr_push(base_data
, flags2
,
1705 p
+2, mangled_name
, 24,
1706 STR_UPPER
|STR_UNICODE
);
1708 memset(p
+ 2 + len
,'\0',24 - len
);
1715 len
= srvstr_push(base_data
, flags2
, p
,
1716 fname
, PTR_DIFF(end_data
, p
),
1717 STR_TERMINATE_ASCII
);
1721 len
= PTR_DIFF(p
, pdata
);
1722 pad
= (len
+ (align
-1)) & ~(align
-1);
1724 * offset to the next entry, the caller
1725 * will overwrite it for the last entry
1726 * that's why we always include the padding
1730 * set padding to zero
1733 memset(p
, 0, pad
- len
);
1740 case SMB_FIND_FILE_DIRECTORY_INFO
:
1741 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_DIRECTORY_INFO\n"));
1743 SIVAL(p
,0,reskey
); p
+= 4;
1744 put_long_date_timespec(conn
->ts_res
,p
,create_date_ts
); p
+= 8;
1745 put_long_date_timespec(conn
->ts_res
,p
,adate_ts
); p
+= 8;
1746 put_long_date_timespec(conn
->ts_res
,p
,mdate_ts
); p
+= 8;
1747 put_long_date_timespec(conn
->ts_res
,p
,cdate_ts
); p
+= 8;
1748 SOFF_T(p
,0,file_size
); p
+= 8;
1749 SOFF_T(p
,0,allocation_size
); p
+= 8;
1750 SIVAL(p
,0,mode
); p
+= 4;
1751 len
= srvstr_push(base_data
, flags2
,
1752 p
+ 4, fname
, PTR_DIFF(end_data
, p
+4),
1753 STR_TERMINATE_ASCII
);
1757 len
= PTR_DIFF(p
, pdata
);
1758 pad
= (len
+ (align
-1)) & ~(align
-1);
1760 * offset to the next entry, the caller
1761 * will overwrite it for the last entry
1762 * that's why we always include the padding
1766 * set padding to zero
1769 memset(p
, 0, pad
- len
);
1776 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
1777 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_FULL_DIRECTORY_INFO\n"));
1779 SIVAL(p
,0,reskey
); p
+= 4;
1780 put_long_date_timespec(conn
->ts_res
,p
,create_date_ts
); p
+= 8;
1781 put_long_date_timespec(conn
->ts_res
,p
,adate_ts
); p
+= 8;
1782 put_long_date_timespec(conn
->ts_res
,p
,mdate_ts
); p
+= 8;
1783 put_long_date_timespec(conn
->ts_res
,p
,cdate_ts
); p
+= 8;
1784 SOFF_T(p
,0,file_size
); p
+= 8;
1785 SOFF_T(p
,0,allocation_size
); p
+= 8;
1786 SIVAL(p
,0,mode
); p
+= 4;
1787 q
= p
; p
+= 4; /* q is placeholder for name length. */
1789 unsigned int ea_size
= estimate_ea_size(conn
, NULL
,
1790 smb_fname
->base_name
);
1791 SIVAL(p
,0,ea_size
); /* Extended attributes */
1794 len
= srvstr_push(base_data
, flags2
, p
,
1795 fname
, PTR_DIFF(end_data
, p
),
1796 STR_TERMINATE_ASCII
);
1800 len
= PTR_DIFF(p
, pdata
);
1801 pad
= (len
+ (align
-1)) & ~(align
-1);
1803 * offset to the next entry, the caller
1804 * will overwrite it for the last entry
1805 * that's why we always include the padding
1809 * set padding to zero
1812 memset(p
, 0, pad
- len
);
1819 case SMB_FIND_FILE_NAMES_INFO
:
1820 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_NAMES_INFO\n"));
1822 SIVAL(p
,0,reskey
); p
+= 4;
1824 /* this must *not* be null terminated or w2k gets in a loop trying to set an
1825 acl on a dir (tridge) */
1826 len
= srvstr_push(base_data
, flags2
, p
,
1827 fname
, PTR_DIFF(end_data
, p
),
1828 STR_TERMINATE_ASCII
);
1832 len
= PTR_DIFF(p
, pdata
);
1833 pad
= (len
+ (align
-1)) & ~(align
-1);
1835 * offset to the next entry, the caller
1836 * will overwrite it for the last entry
1837 * that's why we always include the padding
1841 * set padding to zero
1844 memset(p
, 0, pad
- len
);
1851 case SMB_FIND_ID_FULL_DIRECTORY_INFO
:
1852 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_FULL_DIRECTORY_INFO\n"));
1854 SIVAL(p
,0,reskey
); p
+= 4;
1855 put_long_date_timespec(conn
->ts_res
,p
,create_date_ts
); p
+= 8;
1856 put_long_date_timespec(conn
->ts_res
,p
,adate_ts
); p
+= 8;
1857 put_long_date_timespec(conn
->ts_res
,p
,mdate_ts
); p
+= 8;
1858 put_long_date_timespec(conn
->ts_res
,p
,cdate_ts
); p
+= 8;
1859 SOFF_T(p
,0,file_size
); p
+= 8;
1860 SOFF_T(p
,0,allocation_size
); p
+= 8;
1861 SIVAL(p
,0,mode
); p
+= 4;
1862 q
= p
; p
+= 4; /* q is placeholder for name length. */
1864 unsigned int ea_size
= estimate_ea_size(conn
, NULL
,
1865 smb_fname
->base_name
);
1866 SIVAL(p
,0,ea_size
); /* Extended attributes */
1869 SIVAL(p
,0,0); p
+= 4; /* Unknown - reserved ? */
1870 SIVAL(p
,0,smb_fname
->st
.st_ex_ino
); p
+= 4; /* FileIndexLow */
1871 SIVAL(p
,0,smb_fname
->st
.st_ex_dev
); p
+= 4; /* FileIndexHigh */
1872 len
= srvstr_push(base_data
, flags2
, p
,
1873 fname
, PTR_DIFF(end_data
, p
),
1874 STR_TERMINATE_ASCII
);
1878 len
= PTR_DIFF(p
, pdata
);
1879 pad
= (len
+ (align
-1)) & ~(align
-1);
1881 * offset to the next entry, the caller
1882 * will overwrite it for the last entry
1883 * that's why we always include the padding
1887 * set padding to zero
1890 memset(p
, 0, pad
- len
);
1897 case SMB_FIND_ID_BOTH_DIRECTORY_INFO
:
1898 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_ID_BOTH_DIRECTORY_INFO\n"));
1899 was_8_3
= mangle_is_8_3(fname
, True
, conn
->params
);
1901 SIVAL(p
,0,reskey
); p
+= 4;
1902 put_long_date_timespec(conn
->ts_res
,p
,create_date_ts
); p
+= 8;
1903 put_long_date_timespec(conn
->ts_res
,p
,adate_ts
); p
+= 8;
1904 put_long_date_timespec(conn
->ts_res
,p
,mdate_ts
); p
+= 8;
1905 put_long_date_timespec(conn
->ts_res
,p
,cdate_ts
); p
+= 8;
1906 SOFF_T(p
,0,file_size
); p
+= 8;
1907 SOFF_T(p
,0,allocation_size
); p
+= 8;
1908 SIVAL(p
,0,mode
); p
+= 4;
1909 q
= p
; p
+= 4; /* q is placeholder for name length */
1911 unsigned int ea_size
= estimate_ea_size(conn
, NULL
,
1912 smb_fname
->base_name
);
1913 SIVAL(p
,0,ea_size
); /* Extended attributes */
1916 /* Clear the short name buffer. This is
1917 * IMPORTANT as not doing so will trigger
1918 * a Win2k client bug. JRA.
1920 if (!was_8_3
&& check_mangled_names
) {
1921 char mangled_name
[13]; /* mangled 8.3 name. */
1922 if (!name_to_8_3(fname
,mangled_name
,True
,
1924 /* Error - mangle failed ! */
1925 memset(mangled_name
,'\0',12);
1927 mangled_name
[12] = 0;
1928 len
= srvstr_push(base_data
, flags2
,
1929 p
+2, mangled_name
, 24,
1930 STR_UPPER
|STR_UNICODE
);
1933 memset(p
+ 2 + len
,'\0',24 - len
);
1940 SSVAL(p
,0,0); p
+= 2; /* Reserved ? */
1941 SIVAL(p
,0,smb_fname
->st
.st_ex_ino
); p
+= 4; /* FileIndexLow */
1942 SIVAL(p
,0,smb_fname
->st
.st_ex_dev
); p
+= 4; /* FileIndexHigh */
1943 len
= srvstr_push(base_data
, flags2
, p
,
1944 fname
, PTR_DIFF(end_data
, p
),
1945 STR_TERMINATE_ASCII
);
1949 len
= PTR_DIFF(p
, pdata
);
1950 pad
= (len
+ (align
-1)) & ~(align
-1);
1952 * offset to the next entry, the caller
1953 * will overwrite it for the last entry
1954 * that's why we always include the padding
1958 * set padding to zero
1961 memset(p
, 0, pad
- len
);
1968 /* CIFS UNIX Extension. */
1970 case SMB_FIND_FILE_UNIX
:
1971 case SMB_FIND_FILE_UNIX_INFO2
:
1973 SIVAL(p
,0,reskey
); p
+= 4; /* Used for continuing search. */
1975 /* Begin of SMB_QUERY_FILE_UNIX_BASIC */
1977 if (info_level
== SMB_FIND_FILE_UNIX
) {
1978 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX\n"));
1979 p
= store_file_unix_basic(conn
, p
,
1980 NULL
, &smb_fname
->st
);
1981 len
= srvstr_push(base_data
, flags2
, p
,
1982 fname
, PTR_DIFF(end_data
, p
),
1985 DEBUG(10,("smbd_marshall_dir_entry: SMB_FIND_FILE_UNIX_INFO2\n"));
1986 p
= store_file_unix_basic_info2(conn
, p
,
1987 NULL
, &smb_fname
->st
);
1990 len
= srvstr_push(base_data
, flags2
, p
, fname
,
1991 PTR_DIFF(end_data
, p
), 0);
1992 SIVAL(nameptr
, 0, len
);
1997 len
= PTR_DIFF(p
, pdata
);
1998 pad
= (len
+ (align
-1)) & ~(align
-1);
2000 * offset to the next entry, the caller
2001 * will overwrite it for the last entry
2002 * that's why we always include the padding
2006 * set padding to zero
2009 memset(p
, 0, pad
- len
);
2014 /* End of SMB_QUERY_FILE_UNIX_BASIC */
2022 if (PTR_DIFF(p
,pdata
) > space_remaining
) {
2023 *out_of_space
= true;
2024 DEBUG(9,("smbd_marshall_dir_entry: out of space\n"));
2025 return false; /* Not finished - just out of space */
2028 /* Setup the last entry pointer, as an offset from base_data */
2029 *last_entry_off
= PTR_DIFF(last_entry_ptr
,base_data
);
2030 /* Advance the data pointer to the next slot */
2036 bool smbd_dirptr_lanman2_entry(TALLOC_CTX
*ctx
,
2037 connection_struct
*conn
,
2038 struct dptr_struct
*dirptr
,
2040 const char *path_mask
,
2043 int requires_resume_key
,
2051 int space_remaining
,
2053 bool *got_exact_match
,
2054 int *_last_entry_off
,
2055 struct ea_list
*name_list
)
2058 const char *mask
= NULL
;
2059 long prev_dirpos
= 0;
2062 struct smb_filename
*smb_fname
= NULL
;
2063 struct smbd_dirptr_lanman2_state state
;
2065 uint64_t last_entry_off
= 0;
2069 state
.info_level
= info_level
;
2070 state
.check_mangled_names
= lp_manglednames(conn
->params
);
2071 state
.has_wild
= dptr_has_wild(dirptr
);
2072 state
.got_exact_match
= false;
2074 *out_of_space
= false;
2075 *got_exact_match
= false;
2077 p
= strrchr_m(path_mask
,'/');
2088 ok
= smbd_dirptr_get_entry(ctx
,
2094 smbd_dirptr_lanman2_match_fn
,
2095 smbd_dirptr_lanman2_mode_fn
,
2105 *got_exact_match
= state
.got_exact_match
;
2107 ok
= smbd_marshall_dir_entry(ctx
,
2112 state
.check_mangled_names
,
2113 requires_resume_key
,
2126 TALLOC_FREE(smb_fname
);
2127 if (*out_of_space
) {
2128 dptr_SeekDir(dirptr
, prev_dirpos
);
2135 *_last_entry_off
= last_entry_off
;
2139 static bool get_lanman2_dir_entry(TALLOC_CTX
*ctx
,
2140 connection_struct
*conn
,
2141 struct dptr_struct
*dirptr
,
2143 const char *path_mask
,
2146 bool requires_resume_key
,
2152 int space_remaining
,
2154 bool *got_exact_match
,
2155 int *last_entry_off
,
2156 struct ea_list
*name_list
)
2159 const bool do_pad
= true;
2161 if (info_level
>= 1 && info_level
<= 3) {
2162 /* No alignment on earlier info levels. */
2166 return smbd_dirptr_lanman2_entry(ctx
, conn
, dirptr
, flags2
,
2167 path_mask
, dirtype
, info_level
,
2168 requires_resume_key
, dont_descend
, ask_sharemode
,
2170 ppdata
, base_data
, end_data
,
2172 out_of_space
, got_exact_match
,
2173 last_entry_off
, name_list
);
2176 /****************************************************************************
2177 Reply to a TRANS2_FINDFIRST.
2178 ****************************************************************************/
2180 static void call_trans2findfirst(connection_struct
*conn
,
2181 struct smb_request
*req
,
2182 char **pparams
, int total_params
,
2183 char **ppdata
, int total_data
,
2184 unsigned int max_data_bytes
)
2186 /* We must be careful here that we don't return more than the
2187 allowed number of data bytes. If this means returning fewer than
2188 maxentries then so be it. We assume that the redirector has
2189 enough room for the fixed number of parameter bytes it has
2191 struct smb_filename
*smb_dname
= NULL
;
2192 char *params
= *pparams
;
2193 char *pdata
= *ppdata
;
2197 uint16 findfirst_flags
;
2198 bool close_after_first
;
2200 bool requires_resume_key
;
2202 char *directory
= NULL
;
2205 int last_entry_off
=0;
2209 bool finished
= False
;
2210 bool dont_descend
= False
;
2211 bool out_of_space
= False
;
2212 int space_remaining
;
2213 bool mask_contains_wcard
= False
;
2214 struct ea_list
*ea_list
= NULL
;
2215 NTSTATUS ntstatus
= NT_STATUS_OK
;
2216 bool ask_sharemode
= lp_parm_bool(SNUM(conn
), "smbd", "search ask sharemode", true);
2217 TALLOC_CTX
*ctx
= talloc_tos();
2218 struct dptr_struct
*dirptr
= NULL
;
2219 struct smbd_server_connection
*sconn
= smbd_server_conn
;
2221 if (total_params
< 13) {
2222 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2226 dirtype
= SVAL(params
,0);
2227 maxentries
= SVAL(params
,2);
2228 findfirst_flags
= SVAL(params
,4);
2229 close_after_first
= (findfirst_flags
& FLAG_TRANS2_FIND_CLOSE
);
2230 close_if_end
= (findfirst_flags
& FLAG_TRANS2_FIND_CLOSE_IF_END
);
2231 requires_resume_key
= (findfirst_flags
& FLAG_TRANS2_FIND_REQUIRE_RESUME
);
2232 info_level
= SVAL(params
,6);
2234 DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
2235 close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
2236 (unsigned int)dirtype
, maxentries
, close_after_first
, close_if_end
, requires_resume_key
,
2237 info_level
, max_data_bytes
));
2240 /* W2K3 seems to treat zero as 1. */
2244 switch (info_level
) {
2245 case SMB_FIND_INFO_STANDARD
:
2246 case SMB_FIND_EA_SIZE
:
2247 case SMB_FIND_EA_LIST
:
2248 case SMB_FIND_FILE_DIRECTORY_INFO
:
2249 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
2250 case SMB_FIND_FILE_NAMES_INFO
:
2251 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
2252 case SMB_FIND_ID_FULL_DIRECTORY_INFO
:
2253 case SMB_FIND_ID_BOTH_DIRECTORY_INFO
:
2255 case SMB_FIND_FILE_UNIX
:
2256 case SMB_FIND_FILE_UNIX_INFO2
:
2257 /* Always use filesystem for UNIX mtime query. */
2258 ask_sharemode
= false;
2259 if (!lp_unix_extensions()) {
2260 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2265 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2269 srvstr_get_path_wcard(ctx
, params
, req
->flags2
, &directory
,
2270 params
+12, total_params
- 12,
2271 STR_TERMINATE
, &ntstatus
, &mask_contains_wcard
);
2272 if (!NT_STATUS_IS_OK(ntstatus
)) {
2273 reply_nterror(req
, ntstatus
);
2277 ntstatus
= filename_convert(ctx
, conn
,
2278 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
2281 UCF_ALWAYS_ALLOW_WCARD_LCOMP
),
2282 &mask_contains_wcard
,
2284 if (!NT_STATUS_IS_OK(ntstatus
)) {
2285 if (NT_STATUS_EQUAL(ntstatus
,NT_STATUS_PATH_NOT_COVERED
)) {
2286 reply_botherror(req
, NT_STATUS_PATH_NOT_COVERED
,
2287 ERRSRV
, ERRbadpath
);
2290 reply_nterror(req
, ntstatus
);
2294 mask
= smb_dname
->original_lcomp
;
2296 directory
= smb_dname
->base_name
;
2298 p
= strrchr_m(directory
,'/');
2300 /* Windows and OS/2 systems treat search on the root '\' as if it were '\*' */
2301 if((directory
[0] == '.') && (directory
[1] == '\0')) {
2302 mask
= talloc_strdup(ctx
,"*");
2304 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2307 mask_contains_wcard
= True
;
2309 directory
= talloc_strdup(talloc_tos(), "./");
2311 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2318 DEBUG(5,("dir=%s, mask = %s\n",directory
, mask
));
2320 if (info_level
== SMB_FIND_EA_LIST
) {
2323 if (total_data
< 4) {
2324 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2328 ea_size
= IVAL(pdata
,0);
2329 if (ea_size
!= total_data
) {
2330 DEBUG(4,("call_trans2findfirst: Rejecting EA request with incorrect \
2331 total_data=%u (should be %u)\n", (unsigned int)total_data
, (unsigned int)IVAL(pdata
,0) ));
2332 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2336 if (!lp_ea_support(SNUM(conn
))) {
2337 reply_nterror(req
, NT_STATUS_EAS_NOT_SUPPORTED
);
2341 /* Pull out the list of names. */
2342 ea_list
= read_ea_name_list(ctx
, pdata
+ 4, ea_size
- 4);
2344 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2349 *ppdata
= (char *)SMB_REALLOC(
2350 *ppdata
, max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
);
2351 if(*ppdata
== NULL
) {
2352 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2356 data_end
= pdata
+ max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
- 1;
2358 /* Realloc the params space */
2359 *pparams
= (char *)SMB_REALLOC(*pparams
, 10);
2360 if (*pparams
== NULL
) {
2361 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2366 /* Save the wildcard match and attribs we are using on this directory -
2367 needed as lanman2 assumes these are being saved between calls */
2369 ntstatus
= dptr_create(conn
,
2375 mask_contains_wcard
,
2379 if (!NT_STATUS_IS_OK(ntstatus
)) {
2380 reply_nterror(req
, ntstatus
);
2384 dptr_num
= dptr_dnum(dirptr
);
2385 DEBUG(4,("dptr_num is %d, wcard = %s, attr = %d\n", dptr_num
, mask
, dirtype
));
2387 /* Initialize per TRANS2_FIND_FIRST operation data */
2388 dptr_init_search_op(dirptr
);
2390 /* We don't need to check for VOL here as this is returned by
2391 a different TRANS2 call. */
2393 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2394 directory
,lp_dontdescend(SNUM(conn
))));
2395 if (in_list(directory
,lp_dontdescend(SNUM(conn
)),conn
->case_sensitive
))
2396 dont_descend
= True
;
2399 space_remaining
= max_data_bytes
;
2400 out_of_space
= False
;
2402 for (i
=0;(i
<maxentries
) && !finished
&& !out_of_space
;i
++) {
2403 bool got_exact_match
= False
;
2405 /* this is a heuristic to avoid seeking the dirptr except when
2406 absolutely necessary. It allows for a filename of about 40 chars */
2407 if (space_remaining
< DIRLEN_GUESS
&& numentries
> 0) {
2408 out_of_space
= True
;
2411 finished
= !get_lanman2_dir_entry(ctx
,
2415 mask
,dirtype
,info_level
,
2416 requires_resume_key
,dont_descend
,
2419 space_remaining
, &out_of_space
,
2421 &last_entry_off
, ea_list
);
2424 if (finished
&& out_of_space
)
2427 if (!finished
&& !out_of_space
)
2431 * As an optimisation if we know we aren't looking
2432 * for a wildcard name (ie. the name matches the wildcard exactly)
2433 * then we can finish on any (first) match.
2434 * This speeds up large directory searches. JRA.
2440 /* Ensure space_remaining never goes -ve. */
2441 if (PTR_DIFF(p
,pdata
) > max_data_bytes
) {
2442 space_remaining
= 0;
2443 out_of_space
= true;
2445 space_remaining
= max_data_bytes
- PTR_DIFF(p
,pdata
);
2449 /* Check if we can close the dirptr */
2450 if(close_after_first
|| (finished
&& close_if_end
)) {
2451 DEBUG(5,("call_trans2findfirst - (2) closing dptr_num %d\n", dptr_num
));
2452 dptr_close(sconn
, &dptr_num
);
2456 * If there are no matching entries we must return ERRDOS/ERRbadfile -
2457 * from observation of NT. NB. This changes to ERRDOS,ERRnofiles if
2458 * the protocol level is less than NT1. Tested with smbclient. JRA.
2459 * This should fix the OS/2 client bug #2335.
2462 if(numentries
== 0) {
2463 dptr_close(sconn
, &dptr_num
);
2464 if (get_Protocol() < PROTOCOL_NT1
) {
2465 reply_force_doserror(req
, ERRDOS
, ERRnofiles
);
2468 reply_botherror(req
, NT_STATUS_NO_SUCH_FILE
,
2469 ERRDOS
, ERRbadfile
);
2474 /* At this point pdata points to numentries directory entries. */
2476 /* Set up the return parameter block */
2477 SSVAL(params
,0,dptr_num
);
2478 SSVAL(params
,2,numentries
);
2479 SSVAL(params
,4,finished
);
2480 SSVAL(params
,6,0); /* Never an EA error */
2481 SSVAL(params
,8,last_entry_off
);
2483 send_trans2_replies(conn
, req
, params
, 10, pdata
, PTR_DIFF(p
,pdata
),
2486 if ((! *directory
) && dptr_path(sconn
, dptr_num
)) {
2487 directory
= talloc_strdup(talloc_tos(),dptr_path(sconn
, dptr_num
));
2489 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2493 DEBUG( 4, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2494 smb_fn_name(req
->cmd
),
2495 mask
, directory
, dirtype
, numentries
) );
2498 * Force a name mangle here to ensure that the
2499 * mask as an 8.3 name is top of the mangled cache.
2500 * The reasons for this are subtle. Don't remove
2501 * this code unless you know what you are doing
2502 * (see PR#13758). JRA.
2505 if(!mangle_is_8_3_wildcards( mask
, False
, conn
->params
)) {
2506 char mangled_name
[13];
2507 name_to_8_3(mask
, mangled_name
, True
, conn
->params
);
2510 TALLOC_FREE(smb_dname
);
2514 /****************************************************************************
2515 Reply to a TRANS2_FINDNEXT.
2516 ****************************************************************************/
2518 static void call_trans2findnext(connection_struct
*conn
,
2519 struct smb_request
*req
,
2520 char **pparams
, int total_params
,
2521 char **ppdata
, int total_data
,
2522 unsigned int max_data_bytes
)
2524 /* We must be careful here that we don't return more than the
2525 allowed number of data bytes. If this means returning fewer than
2526 maxentries then so be it. We assume that the redirector has
2527 enough room for the fixed number of parameter bytes it has
2529 char *params
= *pparams
;
2530 char *pdata
= *ppdata
;
2536 uint16 findnext_flags
;
2537 bool close_after_request
;
2539 bool requires_resume_key
;
2541 bool mask_contains_wcard
= False
;
2542 char *resume_name
= NULL
;
2543 const char *mask
= NULL
;
2544 const char *directory
= NULL
;
2548 int i
, last_entry_off
=0;
2549 bool finished
= False
;
2550 bool dont_descend
= False
;
2551 bool out_of_space
= False
;
2552 int space_remaining
;
2553 struct ea_list
*ea_list
= NULL
;
2554 NTSTATUS ntstatus
= NT_STATUS_OK
;
2555 bool ask_sharemode
= lp_parm_bool(SNUM(conn
), "smbd", "search ask sharemode", true);
2556 TALLOC_CTX
*ctx
= talloc_tos();
2557 struct dptr_struct
*dirptr
;
2558 struct smbd_server_connection
*sconn
= smbd_server_conn
;
2560 if (total_params
< 13) {
2561 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2565 dptr_num
= SVAL(params
,0);
2566 maxentries
= SVAL(params
,2);
2567 info_level
= SVAL(params
,4);
2568 resume_key
= IVAL(params
,6);
2569 findnext_flags
= SVAL(params
,10);
2570 close_after_request
= (findnext_flags
& FLAG_TRANS2_FIND_CLOSE
);
2571 close_if_end
= (findnext_flags
& FLAG_TRANS2_FIND_CLOSE_IF_END
);
2572 requires_resume_key
= (findnext_flags
& FLAG_TRANS2_FIND_REQUIRE_RESUME
);
2573 continue_bit
= (findnext_flags
& FLAG_TRANS2_FIND_CONTINUE
);
2575 if (!continue_bit
) {
2576 /* We only need resume_name if continue_bit is zero. */
2577 srvstr_get_path_wcard(ctx
, params
, req
->flags2
, &resume_name
,
2579 total_params
- 12, STR_TERMINATE
, &ntstatus
,
2580 &mask_contains_wcard
);
2581 if (!NT_STATUS_IS_OK(ntstatus
)) {
2582 /* Win9x or OS/2 can send a resume name of ".." or ".". This will cause the parser to
2583 complain (it thinks we're asking for the directory above the shared
2584 path or an invalid name). Catch this as the resume name is only compared, never used in
2585 a file access. JRA. */
2586 srvstr_pull_talloc(ctx
, params
, req
->flags2
,
2587 &resume_name
, params
+12,
2591 if (!resume_name
|| !(ISDOT(resume_name
) || ISDOTDOT(resume_name
))) {
2592 reply_nterror(req
, ntstatus
);
2598 DEBUG(3,("call_trans2findnext: dirhandle = %d, max_data_bytes = %d, maxentries = %d, \
2599 close_after_request=%d, close_if_end = %d requires_resume_key = %d \
2600 resume_key = %d resume name = %s continue=%d level = %d\n",
2601 dptr_num
, max_data_bytes
, maxentries
, close_after_request
, close_if_end
,
2602 requires_resume_key
, resume_key
,
2603 resume_name
? resume_name
: "(NULL)", continue_bit
, info_level
));
2606 /* W2K3 seems to treat zero as 1. */
2610 switch (info_level
) {
2611 case SMB_FIND_INFO_STANDARD
:
2612 case SMB_FIND_EA_SIZE
:
2613 case SMB_FIND_EA_LIST
:
2614 case SMB_FIND_FILE_DIRECTORY_INFO
:
2615 case SMB_FIND_FILE_FULL_DIRECTORY_INFO
:
2616 case SMB_FIND_FILE_NAMES_INFO
:
2617 case SMB_FIND_FILE_BOTH_DIRECTORY_INFO
:
2618 case SMB_FIND_ID_FULL_DIRECTORY_INFO
:
2619 case SMB_FIND_ID_BOTH_DIRECTORY_INFO
:
2621 case SMB_FIND_FILE_UNIX
:
2622 case SMB_FIND_FILE_UNIX_INFO2
:
2623 /* Always use filesystem for UNIX mtime query. */
2624 ask_sharemode
= false;
2625 if (!lp_unix_extensions()) {
2626 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2631 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
2635 if (info_level
== SMB_FIND_EA_LIST
) {
2638 if (total_data
< 4) {
2639 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2643 ea_size
= IVAL(pdata
,0);
2644 if (ea_size
!= total_data
) {
2645 DEBUG(4,("call_trans2findnext: Rejecting EA request with incorrect \
2646 total_data=%u (should be %u)\n", (unsigned int)total_data
, (unsigned int)IVAL(pdata
,0) ));
2647 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2651 if (!lp_ea_support(SNUM(conn
))) {
2652 reply_nterror(req
, NT_STATUS_EAS_NOT_SUPPORTED
);
2656 /* Pull out the list of names. */
2657 ea_list
= read_ea_name_list(ctx
, pdata
+ 4, ea_size
- 4);
2659 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
2664 *ppdata
= (char *)SMB_REALLOC(
2665 *ppdata
, max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
);
2666 if(*ppdata
== NULL
) {
2667 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2672 data_end
= pdata
+ max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
- 1;
2674 /* Realloc the params space */
2675 *pparams
= (char *)SMB_REALLOC(*pparams
, 6*SIZEOFWORD
);
2676 if(*pparams
== NULL
) {
2677 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
2683 /* Check that the dptr is valid */
2684 if(!(dirptr
= dptr_fetch_lanman2(sconn
, dptr_num
))) {
2685 reply_nterror(req
, STATUS_NO_MORE_FILES
);
2689 directory
= dptr_path(sconn
, dptr_num
);
2691 /* Get the wildcard mask from the dptr */
2692 if((p
= dptr_wcard(sconn
, dptr_num
))== NULL
) {
2693 DEBUG(2,("dptr_num %d has no wildcard\n", dptr_num
));
2694 reply_nterror(req
, STATUS_NO_MORE_FILES
);
2700 /* Get the attr mask from the dptr */
2701 dirtype
= dptr_attr(sconn
, dptr_num
);
2703 DEBUG(3,("dptr_num is %d, mask = %s, attr = %x, dirptr=(0x%lX,%ld)\n",
2704 dptr_num
, mask
, dirtype
,
2706 dptr_TellDir(dirptr
)));
2708 /* Initialize per TRANS2_FIND_NEXT operation data */
2709 dptr_init_search_op(dirptr
);
2711 /* We don't need to check for VOL here as this is returned by
2712 a different TRANS2 call. */
2714 DEBUG(8,("dirpath=<%s> dontdescend=<%s>\n",
2715 directory
,lp_dontdescend(SNUM(conn
))));
2716 if (in_list(directory
,lp_dontdescend(SNUM(conn
)),conn
->case_sensitive
))
2717 dont_descend
= True
;
2720 space_remaining
= max_data_bytes
;
2721 out_of_space
= False
;
2724 * Seek to the correct position. We no longer use the resume key but
2725 * depend on the last file name instead.
2728 if(!continue_bit
&& resume_name
&& *resume_name
) {
2731 long current_pos
= 0;
2733 * Remember, name_to_8_3 is called by
2734 * get_lanman2_dir_entry(), so the resume name
2735 * could be mangled. Ensure we check the unmangled name.
2738 if (mangle_is_mangled(resume_name
, conn
->params
)) {
2739 char *new_resume_name
= NULL
;
2740 mangle_lookup_name_from_8_3(ctx
,
2744 if (new_resume_name
) {
2745 resume_name
= new_resume_name
;
2750 * Fix for NT redirector problem triggered by resume key indexes
2751 * changing between directory scans. We now return a resume key of 0
2752 * and instead look for the filename to continue from (also given
2753 * to us by NT/95/smbfs/smbclient). If no other scans have been done between the
2754 * findfirst/findnext (as is usual) then the directory pointer
2755 * should already be at the correct place.
2758 finished
= !dptr_SearchDir(dirptr
, resume_name
, ¤t_pos
, &st
);
2759 } /* end if resume_name && !continue_bit */
2761 for (i
=0;(i
<(int)maxentries
) && !finished
&& !out_of_space
;i
++) {
2762 bool got_exact_match
= False
;
2764 /* this is a heuristic to avoid seeking the dirptr except when
2765 absolutely necessary. It allows for a filename of about 40 chars */
2766 if (space_remaining
< DIRLEN_GUESS
&& numentries
> 0) {
2767 out_of_space
= True
;
2770 finished
= !get_lanman2_dir_entry(ctx
,
2774 mask
,dirtype
,info_level
,
2775 requires_resume_key
,dont_descend
,
2778 space_remaining
, &out_of_space
,
2780 &last_entry_off
, ea_list
);
2783 if (finished
&& out_of_space
)
2786 if (!finished
&& !out_of_space
)
2790 * As an optimisation if we know we aren't looking
2791 * for a wildcard name (ie. the name matches the wildcard exactly)
2792 * then we can finish on any (first) match.
2793 * This speeds up large directory searches. JRA.
2799 space_remaining
= max_data_bytes
- PTR_DIFF(p
,pdata
);
2802 DEBUG( 3, ( "%s mask=%s directory=%s dirtype=%d numentries=%d\n",
2803 smb_fn_name(req
->cmd
),
2804 mask
, directory
, dirtype
, numentries
) );
2806 /* Check if we can close the dirptr */
2807 if(close_after_request
|| (finished
&& close_if_end
)) {
2808 DEBUG(5,("call_trans2findnext: closing dptr_num = %d\n", dptr_num
));
2809 dptr_close(sconn
, &dptr_num
); /* This frees up the saved mask */
2812 /* Set up the return parameter block */
2813 SSVAL(params
,0,numentries
);
2814 SSVAL(params
,2,finished
);
2815 SSVAL(params
,4,0); /* Never an EA error */
2816 SSVAL(params
,6,last_entry_off
);
2818 send_trans2_replies(conn
, req
, params
, 8, pdata
, PTR_DIFF(p
,pdata
),
2824 unsigned char *create_volume_objectid(connection_struct
*conn
, unsigned char objid
[16])
2826 E_md4hash(lp_servicename(SNUM(conn
)),objid
);
2830 static void samba_extended_info_version(struct smb_extended_info
*extended_info
)
2832 SMB_ASSERT(extended_info
!= NULL
);
2834 extended_info
->samba_magic
= SAMBA_EXTENDED_INFO_MAGIC
;
2835 extended_info
->samba_version
= ((SAMBA_VERSION_MAJOR
& 0xff) << 24)
2836 | ((SAMBA_VERSION_MINOR
& 0xff) << 16)
2837 | ((SAMBA_VERSION_RELEASE
& 0xff) << 8);
2838 #ifdef SAMBA_VERSION_REVISION
2839 extended_info
->samba_version
|= (tolower(*SAMBA_VERSION_REVISION
) - 'a' + 1) & 0xff;
2841 extended_info
->samba_subversion
= 0;
2842 #ifdef SAMBA_VERSION_RC_RELEASE
2843 extended_info
->samba_subversion
|= (SAMBA_VERSION_RC_RELEASE
& 0xff) << 24;
2845 #ifdef SAMBA_VERSION_PRE_RELEASE
2846 extended_info
->samba_subversion
|= (SAMBA_VERSION_PRE_RELEASE
& 0xff) << 16;
2849 #ifdef SAMBA_VERSION_VENDOR_PATCH
2850 extended_info
->samba_subversion
|= (SAMBA_VERSION_VENDOR_PATCH
& 0xffff);
2852 extended_info
->samba_gitcommitdate
= 0;
2853 #ifdef SAMBA_VERSION_GIT_COMMIT_TIME
2854 unix_to_nt_time(&extended_info
->samba_gitcommitdate
, SAMBA_VERSION_GIT_COMMIT_TIME
);
2857 memset(extended_info
->samba_version_string
, 0,
2858 sizeof(extended_info
->samba_version_string
));
2860 snprintf (extended_info
->samba_version_string
,
2861 sizeof(extended_info
->samba_version_string
),
2862 "%s", samba_version_string());
2865 NTSTATUS
smbd_do_qfsinfo(connection_struct
*conn
,
2866 TALLOC_CTX
*mem_ctx
,
2867 uint16_t info_level
,
2869 unsigned int max_data_bytes
,
2873 char *pdata
, *end_data
;
2874 int data_len
= 0, len
;
2875 const char *vname
= volume_label(SNUM(conn
));
2876 int snum
= SNUM(conn
);
2877 char *fstype
= lp_fstype(SNUM(conn
));
2878 uint32 additional_flags
= 0;
2879 struct smb_filename smb_fname_dot
;
2883 if (info_level
!= SMB_QUERY_CIFS_UNIX_INFO
) {
2884 DEBUG(0,("smbd_do_qfsinfo: not an allowed "
2885 "info level (0x%x) on IPC$.\n",
2886 (unsigned int)info_level
));
2887 return NT_STATUS_ACCESS_DENIED
;
2891 DEBUG(3,("smbd_do_qfsinfo: level = %d\n", info_level
));
2893 ZERO_STRUCT(smb_fname_dot
);
2894 smb_fname_dot
.base_name
= discard_const_p(char, ".");
2896 if(SMB_VFS_STAT(conn
, &smb_fname_dot
) != 0) {
2897 DEBUG(2,("stat of . failed (%s)\n", strerror(errno
)));
2898 return map_nt_error_from_unix(errno
);
2901 st
= smb_fname_dot
.st
;
2903 *ppdata
= (char *)SMB_REALLOC(
2904 *ppdata
, max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
);
2905 if (*ppdata
== NULL
) {
2906 return NT_STATUS_NO_MEMORY
;
2910 memset((char *)pdata
,'\0',max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
);
2911 end_data
= pdata
+ max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
- 1;
2913 switch (info_level
) {
2914 case SMB_INFO_ALLOCATION
:
2916 uint64_t dfree
,dsize
,bsize
,block_size
,sectors_per_unit
,bytes_per_sector
;
2918 if (get_dfree_info(conn
,".",False
,&bsize
,&dfree
,&dsize
) == (uint64_t)-1) {
2919 return map_nt_error_from_unix(errno
);
2922 block_size
= lp_block_size(snum
);
2923 if (bsize
< block_size
) {
2924 uint64_t factor
= block_size
/bsize
;
2929 if (bsize
> block_size
) {
2930 uint64_t factor
= bsize
/block_size
;
2935 bytes_per_sector
= 512;
2936 sectors_per_unit
= bsize
/bytes_per_sector
;
2938 DEBUG(5,("smbd_do_qfsinfo : SMB_INFO_ALLOCATION id=%x, bsize=%u, cSectorUnit=%u, \
2939 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)st
.st_ex_dev
, (unsigned int)bsize
, (unsigned int)sectors_per_unit
,
2940 (unsigned int)bytes_per_sector
, (unsigned int)dsize
, (unsigned int)dfree
));
2942 SIVAL(pdata
,l1_idFileSystem
,st
.st_ex_dev
);
2943 SIVAL(pdata
,l1_cSectorUnit
,sectors_per_unit
);
2944 SIVAL(pdata
,l1_cUnit
,dsize
);
2945 SIVAL(pdata
,l1_cUnitAvail
,dfree
);
2946 SSVAL(pdata
,l1_cbSector
,bytes_per_sector
);
2950 case SMB_INFO_VOLUME
:
2951 /* Return volume name */
2953 * Add volume serial number - hash of a combination of
2954 * the called hostname and the service name.
2956 SIVAL(pdata
,0,str_checksum(lp_servicename(snum
)) ^ (str_checksum(get_local_machine_name())<<16) );
2958 * Win2k3 and previous mess this up by sending a name length
2959 * one byte short. I believe only older clients (OS/2 Win9x) use
2960 * this call so try fixing this by adding a terminating null to
2961 * the pushed string. The change here was adding the STR_TERMINATE. JRA.
2965 pdata
+l2_vol_szVolLabel
, vname
,
2966 PTR_DIFF(end_data
, pdata
+l2_vol_szVolLabel
),
2967 STR_NOALIGN
|STR_TERMINATE
);
2968 SCVAL(pdata
,l2_vol_cch
,len
);
2969 data_len
= l2_vol_szVolLabel
+ len
;
2970 DEBUG(5,("smbd_do_qfsinfo : time = %x, namelen = %d, name = %s\n",
2971 (unsigned)convert_timespec_to_time_t(st
.st_ex_ctime
),
2975 case SMB_QUERY_FS_ATTRIBUTE_INFO
:
2976 case SMB_FS_ATTRIBUTE_INFORMATION
:
2978 additional_flags
= 0;
2979 #if defined(HAVE_SYS_QUOTAS)
2980 additional_flags
|= FILE_VOLUME_QUOTAS
;
2983 if(lp_nt_acl_support(SNUM(conn
))) {
2984 additional_flags
|= FILE_PERSISTENT_ACLS
;
2987 /* Capabilities are filled in at connection time through STATVFS call */
2988 additional_flags
|= conn
->fs_capabilities
;
2989 additional_flags
|= lp_parm_int(conn
->params
->service
,
2990 "share", "fake_fscaps",
2993 SIVAL(pdata
,0,FILE_CASE_PRESERVED_NAMES
|FILE_CASE_SENSITIVE_SEARCH
|
2994 FILE_SUPPORTS_OBJECT_IDS
|FILE_UNICODE_ON_DISK
|
2995 additional_flags
); /* FS ATTRIBUTES */
2997 SIVAL(pdata
,4,255); /* Max filename component length */
2998 /* NOTE! the fstype must *not* be null terminated or win98 won't recognise it
2999 and will think we can't do long filenames */
3000 len
= srvstr_push(pdata
, flags2
, pdata
+12, fstype
,
3001 PTR_DIFF(end_data
, pdata
+12),
3004 data_len
= 12 + len
;
3007 case SMB_QUERY_FS_LABEL_INFO
:
3008 case SMB_FS_LABEL_INFORMATION
:
3009 len
= srvstr_push(pdata
, flags2
, pdata
+4, vname
,
3010 PTR_DIFF(end_data
, pdata
+4), 0);
3015 case SMB_QUERY_FS_VOLUME_INFO
:
3016 case SMB_FS_VOLUME_INFORMATION
:
3019 * Add volume serial number - hash of a combination of
3020 * the called hostname and the service name.
3022 SIVAL(pdata
,8,str_checksum(lp_servicename(snum
)) ^
3023 (str_checksum(get_local_machine_name())<<16));
3025 /* Max label len is 32 characters. */
3026 len
= srvstr_push(pdata
, flags2
, pdata
+18, vname
,
3027 PTR_DIFF(end_data
, pdata
+18),
3029 SIVAL(pdata
,12,len
);
3032 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_VOLUME_INFO namelen = %d, vol=%s serv=%s\n",
3033 (int)strlen(vname
),vname
, lp_servicename(snum
)));
3036 case SMB_QUERY_FS_SIZE_INFO
:
3037 case SMB_FS_SIZE_INFORMATION
:
3039 uint64_t dfree
,dsize
,bsize
,block_size
,sectors_per_unit
,bytes_per_sector
;
3041 if (get_dfree_info(conn
,".",False
,&bsize
,&dfree
,&dsize
) == (uint64_t)-1) {
3042 return map_nt_error_from_unix(errno
);
3044 block_size
= lp_block_size(snum
);
3045 if (bsize
< block_size
) {
3046 uint64_t factor
= block_size
/bsize
;
3051 if (bsize
> block_size
) {
3052 uint64_t factor
= bsize
/block_size
;
3057 bytes_per_sector
= 512;
3058 sectors_per_unit
= bsize
/bytes_per_sector
;
3059 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3060 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize
, (unsigned int)sectors_per_unit
,
3061 (unsigned int)bytes_per_sector
, (unsigned int)dsize
, (unsigned int)dfree
));
3062 SBIG_UINT(pdata
,0,dsize
);
3063 SBIG_UINT(pdata
,8,dfree
);
3064 SIVAL(pdata
,16,sectors_per_unit
);
3065 SIVAL(pdata
,20,bytes_per_sector
);
3069 case SMB_FS_FULL_SIZE_INFORMATION
:
3071 uint64_t dfree
,dsize
,bsize
,block_size
,sectors_per_unit
,bytes_per_sector
;
3073 if (get_dfree_info(conn
,".",False
,&bsize
,&dfree
,&dsize
) == (uint64_t)-1) {
3074 return map_nt_error_from_unix(errno
);
3076 block_size
= lp_block_size(snum
);
3077 if (bsize
< block_size
) {
3078 uint64_t factor
= block_size
/bsize
;
3083 if (bsize
> block_size
) {
3084 uint64_t factor
= bsize
/block_size
;
3089 bytes_per_sector
= 512;
3090 sectors_per_unit
= bsize
/bytes_per_sector
;
3091 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_FS_FULL_SIZE_INFO bsize=%u, cSectorUnit=%u, \
3092 cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize
, (unsigned int)sectors_per_unit
,
3093 (unsigned int)bytes_per_sector
, (unsigned int)dsize
, (unsigned int)dfree
));
3094 SBIG_UINT(pdata
,0,dsize
); /* Total Allocation units. */
3095 SBIG_UINT(pdata
,8,dfree
); /* Caller available allocation units. */
3096 SBIG_UINT(pdata
,16,dfree
); /* Actual available allocation units. */
3097 SIVAL(pdata
,24,sectors_per_unit
); /* Sectors per allocation unit. */
3098 SIVAL(pdata
,28,bytes_per_sector
); /* Bytes per sector. */
3102 case SMB_QUERY_FS_DEVICE_INFO
:
3103 case SMB_FS_DEVICE_INFORMATION
:
3105 SIVAL(pdata
,0,0); /* dev type */
3106 SIVAL(pdata
,4,0); /* characteristics */
3109 #ifdef HAVE_SYS_QUOTAS
3110 case SMB_FS_QUOTA_INFORMATION
:
3112 * what we have to send --metze:
3114 * Unknown1: 24 NULL bytes
3115 * Soft Quota Treshold: 8 bytes seems like uint64_t or so
3116 * Hard Quota Limit: 8 bytes seems like uint64_t or so
3117 * Quota Flags: 2 byte :
3118 * Unknown3: 6 NULL bytes
3122 * details for Quota Flags:
3124 * 0x0020 Log Limit: log if the user exceeds his Hard Quota
3125 * 0x0010 Log Warn: log if the user exceeds his Soft Quota
3126 * 0x0002 Deny Disk: deny disk access when the user exceeds his Hard Quota
3127 * 0x0001 Enable Quotas: enable quota for this fs
3131 /* we need to fake up a fsp here,
3132 * because its not send in this call
3135 SMB_NTQUOTA_STRUCT quotas
;
3138 ZERO_STRUCT(quotas
);
3144 if (conn
->server_info
->utok
.uid
!= sec_initial_uid()) {
3145 DEBUG(0,("set_user_quota: access_denied "
3146 "service [%s] user [%s]\n",
3147 lp_servicename(SNUM(conn
)),
3148 conn
->server_info
->unix_name
));
3149 return NT_STATUS_ACCESS_DENIED
;
3152 if (vfs_get_ntquota(&fsp
, SMB_USER_FS_QUOTA_TYPE
, NULL
, "as
)!=0) {
3153 DEBUG(0,("vfs_get_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn
))));
3154 return map_nt_error_from_unix(errno
);
3159 DEBUG(10,("SMB_FS_QUOTA_INFORMATION: for service [%s]\n",
3160 lp_servicename(SNUM(conn
))));
3162 /* Unknown1 24 NULL bytes*/
3163 SBIG_UINT(pdata
,0,(uint64_t)0);
3164 SBIG_UINT(pdata
,8,(uint64_t)0);
3165 SBIG_UINT(pdata
,16,(uint64_t)0);
3167 /* Default Soft Quota 8 bytes */
3168 SBIG_UINT(pdata
,24,quotas
.softlim
);
3170 /* Default Hard Quota 8 bytes */
3171 SBIG_UINT(pdata
,32,quotas
.hardlim
);
3173 /* Quota flag 2 bytes */
3174 SSVAL(pdata
,40,quotas
.qflags
);
3176 /* Unknown3 6 NULL bytes */
3182 #endif /* HAVE_SYS_QUOTAS */
3183 case SMB_FS_OBJECTID_INFORMATION
:
3185 unsigned char objid
[16];
3186 struct smb_extended_info extended_info
;
3187 memcpy(pdata
,create_volume_objectid(conn
, objid
),16);
3188 samba_extended_info_version (&extended_info
);
3189 SIVAL(pdata
,16,extended_info
.samba_magic
);
3190 SIVAL(pdata
,20,extended_info
.samba_version
);
3191 SIVAL(pdata
,24,extended_info
.samba_subversion
);
3192 SBIG_UINT(pdata
,28,extended_info
.samba_gitcommitdate
);
3193 memcpy(pdata
+36,extended_info
.samba_version_string
,28);
3199 * Query the version and capabilities of the CIFS UNIX extensions
3203 case SMB_QUERY_CIFS_UNIX_INFO
:
3205 bool large_write
= lp_min_receive_file_size() &&
3206 !srv_is_signing_active(smbd_server_conn
);
3207 bool large_read
= !srv_is_signing_active(smbd_server_conn
);
3208 int encrypt_caps
= 0;
3210 if (!lp_unix_extensions()) {
3211 return NT_STATUS_INVALID_LEVEL
;
3214 switch (conn
->encrypt_level
) {
3220 encrypt_caps
= CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
;
3223 encrypt_caps
= CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
|
3224 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
;
3225 large_write
= false;
3231 SSVAL(pdata
,0,CIFS_UNIX_MAJOR_VERSION
);
3232 SSVAL(pdata
,2,CIFS_UNIX_MINOR_VERSION
);
3234 /* We have POSIX ACLs, pathname, encryption,
3235 * large read/write, and locking capability. */
3237 SBIG_UINT(pdata
,4,((uint64_t)(
3238 CIFS_UNIX_POSIX_ACLS_CAP
|
3239 CIFS_UNIX_POSIX_PATHNAMES_CAP
|
3240 CIFS_UNIX_FCNTL_LOCKS_CAP
|
3241 CIFS_UNIX_EXTATTR_CAP
|
3242 CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP
|
3244 (large_read
? CIFS_UNIX_LARGE_READ_CAP
: 0) |
3246 CIFS_UNIX_LARGE_WRITE_CAP
: 0))));
3250 case SMB_QUERY_POSIX_FS_INFO
:
3253 vfs_statvfs_struct svfs
;
3255 if (!lp_unix_extensions()) {
3256 return NT_STATUS_INVALID_LEVEL
;
3259 rc
= SMB_VFS_STATVFS(conn
, ".", &svfs
);
3263 SIVAL(pdata
,0,svfs
.OptimalTransferSize
);
3264 SIVAL(pdata
,4,svfs
.BlockSize
);
3265 SBIG_UINT(pdata
,8,svfs
.TotalBlocks
);
3266 SBIG_UINT(pdata
,16,svfs
.BlocksAvail
);
3267 SBIG_UINT(pdata
,24,svfs
.UserBlocksAvail
);
3268 SBIG_UINT(pdata
,32,svfs
.TotalFileNodes
);
3269 SBIG_UINT(pdata
,40,svfs
.FreeFileNodes
);
3270 SBIG_UINT(pdata
,48,svfs
.FsIdentifier
);
3271 DEBUG(5,("smbd_do_qfsinfo : SMB_QUERY_POSIX_FS_INFO succsessful\n"));
3273 } else if (rc
== EOPNOTSUPP
) {
3274 return NT_STATUS_INVALID_LEVEL
;
3275 #endif /* EOPNOTSUPP */
3277 DEBUG(0,("vfs_statvfs() failed for service [%s]\n",lp_servicename(SNUM(conn
))));
3278 return NT_STATUS_DOS(ERRSRV
, ERRerror
);
3283 case SMB_QUERY_POSIX_WHOAMI
:
3289 if (!lp_unix_extensions()) {
3290 return NT_STATUS_INVALID_LEVEL
;
3293 if (max_data_bytes
< 40) {
3294 return NT_STATUS_BUFFER_TOO_SMALL
;
3297 /* We ARE guest if global_sid_Builtin_Guests is
3298 * in our list of SIDs.
3300 if (nt_token_check_sid(&global_sid_Builtin_Guests
,
3301 conn
->server_info
->ptok
)) {
3302 flags
|= SMB_WHOAMI_GUEST
;
3305 /* We are NOT guest if global_sid_Authenticated_Users
3306 * is in our list of SIDs.
3308 if (nt_token_check_sid(&global_sid_Authenticated_Users
,
3309 conn
->server_info
->ptok
)) {
3310 flags
&= ~SMB_WHOAMI_GUEST
;
3313 /* NOTE: 8 bytes for UID/GID, irrespective of native
3314 * platform size. This matches
3315 * SMB_QUERY_FILE_UNIX_BASIC and friends.
3317 data_len
= 4 /* flags */
3324 + 4 /* pad/reserved */
3325 + (conn
->server_info
->utok
.ngroups
* 8)
3327 + (conn
->server_info
->ptok
->num_sids
*
3331 SIVAL(pdata
, 0, flags
);
3332 SIVAL(pdata
, 4, SMB_WHOAMI_MASK
);
3334 (uint64_t)conn
->server_info
->utok
.uid
);
3335 SBIG_UINT(pdata
, 16,
3336 (uint64_t)conn
->server_info
->utok
.gid
);
3339 if (data_len
>= max_data_bytes
) {
3340 /* Potential overflow, skip the GIDs and SIDs. */
3342 SIVAL(pdata
, 24, 0); /* num_groups */
3343 SIVAL(pdata
, 28, 0); /* num_sids */
3344 SIVAL(pdata
, 32, 0); /* num_sid_bytes */
3345 SIVAL(pdata
, 36, 0); /* reserved */
3351 SIVAL(pdata
, 24, conn
->server_info
->utok
.ngroups
);
3352 SIVAL(pdata
, 28, conn
->server_info
->num_sids
);
3354 /* We walk the SID list twice, but this call is fairly
3355 * infrequent, and I don't expect that it's performance
3356 * sensitive -- jpeach
3358 for (i
= 0, sid_bytes
= 0;
3359 i
< conn
->server_info
->ptok
->num_sids
; ++i
) {
3360 sid_bytes
+= ndr_size_dom_sid(
3361 &conn
->server_info
->ptok
->user_sids
[i
],
3366 /* SID list byte count */
3367 SIVAL(pdata
, 32, sid_bytes
);
3369 /* 4 bytes pad/reserved - must be zero */
3370 SIVAL(pdata
, 36, 0);
3374 for (i
= 0; i
< conn
->server_info
->utok
.ngroups
; ++i
) {
3375 SBIG_UINT(pdata
, data_len
,
3376 (uint64_t)conn
->server_info
->utok
.groups
[i
]);
3382 i
< conn
->server_info
->ptok
->num_sids
; ++i
) {
3383 int sid_len
= ndr_size_dom_sid(
3384 &conn
->server_info
->ptok
->user_sids
[i
],
3388 sid_linearize(pdata
+ data_len
, sid_len
,
3389 &conn
->server_info
->ptok
->user_sids
[i
]);
3390 data_len
+= sid_len
;
3396 case SMB_MAC_QUERY_FS_INFO
:
3398 * Thursby MAC extension... ONLY on NTFS filesystems
3399 * once we do streams then we don't need this
3401 if (strequal(lp_fstype(SNUM(conn
)),"NTFS")) {
3403 SIVAL(pdata
,84,0x100); /* Don't support mac... */
3408 return NT_STATUS_INVALID_LEVEL
;
3411 *ret_data_len
= data_len
;
3412 return NT_STATUS_OK
;
3415 /****************************************************************************
3416 Reply to a TRANS2_QFSINFO (query filesystem info).
3417 ****************************************************************************/
3419 static void call_trans2qfsinfo(connection_struct
*conn
,
3420 struct smb_request
*req
,
3421 char **pparams
, int total_params
,
3422 char **ppdata
, int total_data
,
3423 unsigned int max_data_bytes
)
3425 char *params
= *pparams
;
3426 uint16_t info_level
;
3430 if (total_params
< 2) {
3431 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
3435 info_level
= SVAL(params
,0);
3437 if (ENCRYPTION_REQUIRED(conn
) && !req
->encrypted
) {
3438 if (info_level
!= SMB_QUERY_CIFS_UNIX_INFO
) {
3439 DEBUG(0,("call_trans2qfsinfo: encryption required "
3440 "and info level 0x%x sent.\n",
3441 (unsigned int)info_level
));
3442 exit_server_cleanly("encryption required "
3448 DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level
));
3450 status
= smbd_do_qfsinfo(conn
, req
,
3455 if (!NT_STATUS_IS_OK(status
)) {
3456 reply_nterror(req
, status
);
3460 send_trans2_replies(conn
, req
, params
, 0, *ppdata
, data_len
,
3463 DEBUG( 4, ( "%s info_level = %d\n",
3464 smb_fn_name(req
->cmd
), info_level
) );
3469 /****************************************************************************
3470 Reply to a TRANS2_SETFSINFO (set filesystem info).
3471 ****************************************************************************/
3473 static void call_trans2setfsinfo(connection_struct
*conn
,
3474 struct smb_request
*req
,
3475 char **pparams
, int total_params
,
3476 char **ppdata
, int total_data
,
3477 unsigned int max_data_bytes
)
3479 char *pdata
= *ppdata
;
3480 char *params
= *pparams
;
3483 DEBUG(10,("call_trans2setfsinfo: for service [%s]\n",lp_servicename(SNUM(conn
))));
3486 if (total_params
< 4) {
3487 DEBUG(0,("call_trans2setfsinfo: requires total_params(%d) >= 4 bytes!\n",
3489 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
3493 info_level
= SVAL(params
,2);
3496 if (info_level
!= SMB_REQUEST_TRANSPORT_ENCRYPTION
&&
3497 info_level
!= SMB_SET_CIFS_UNIX_INFO
) {
3498 DEBUG(0,("call_trans2setfsinfo: not an allowed "
3499 "info level (0x%x) on IPC$.\n",
3500 (unsigned int)info_level
));
3501 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
3506 if (ENCRYPTION_REQUIRED(conn
) && !req
->encrypted
) {
3507 if (info_level
!= SMB_REQUEST_TRANSPORT_ENCRYPTION
) {
3508 DEBUG(0,("call_trans2setfsinfo: encryption required "
3509 "and info level 0x%x sent.\n",
3510 (unsigned int)info_level
));
3511 exit_server_cleanly("encryption required "
3517 switch(info_level
) {
3518 case SMB_SET_CIFS_UNIX_INFO
:
3520 uint16 client_unix_major
;
3521 uint16 client_unix_minor
;
3522 uint32 client_unix_cap_low
;
3523 uint32 client_unix_cap_high
;
3525 if (!lp_unix_extensions()) {
3527 NT_STATUS_INVALID_LEVEL
);
3531 /* There should be 12 bytes of capabilities set. */
3532 if (total_data
< 8) {
3535 NT_STATUS_INVALID_PARAMETER
);
3538 client_unix_major
= SVAL(pdata
,0);
3539 client_unix_minor
= SVAL(pdata
,2);
3540 client_unix_cap_low
= IVAL(pdata
,4);
3541 client_unix_cap_high
= IVAL(pdata
,8);
3542 /* Just print these values for now. */
3543 DEBUG(10,("call_trans2setfsinfo: set unix info. major = %u, minor = %u \
3544 cap_low = 0x%x, cap_high = 0x%x\n",
3545 (unsigned int)client_unix_major
,
3546 (unsigned int)client_unix_minor
,
3547 (unsigned int)client_unix_cap_low
,
3548 (unsigned int)client_unix_cap_high
));
3550 /* Here is where we must switch to posix pathname processing... */
3551 if (client_unix_cap_low
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3552 lp_set_posix_pathnames();
3553 mangle_change_to_posix();
3556 if ((client_unix_cap_low
& CIFS_UNIX_FCNTL_LOCKS_CAP
) &&
3557 !(client_unix_cap_low
& CIFS_UNIX_POSIX_PATH_OPERATIONS_CAP
)) {
3558 /* Client that knows how to do posix locks,
3559 * but not posix open/mkdir operations. Set a
3560 * default type for read/write checks. */
3562 lp_set_posix_default_cifsx_readwrite_locktype(POSIX_LOCK
);
3568 case SMB_REQUEST_TRANSPORT_ENCRYPTION
:
3571 size_t param_len
= 0;
3572 size_t data_len
= total_data
;
3574 if (!lp_unix_extensions()) {
3577 NT_STATUS_INVALID_LEVEL
);
3581 if (lp_smb_encrypt(SNUM(conn
)) == false) {
3584 NT_STATUS_NOT_SUPPORTED
);
3588 if (smbd_server_conn
->smb1
.echo_handler
.trusted_fde
) {
3589 DEBUG( 2,("call_trans2setfsinfo: "
3590 "request transport encryption disabled"
3591 "with 'fork echo handler = yes'\n"));
3594 NT_STATUS_NOT_SUPPORTED
);
3598 DEBUG( 4,("call_trans2setfsinfo: "
3599 "request transport encryption.\n"));
3601 status
= srv_request_encryption_setup(conn
,
3602 (unsigned char **)ppdata
,
3604 (unsigned char **)pparams
,
3607 if (!NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
) &&
3608 !NT_STATUS_IS_OK(status
)) {
3609 reply_nterror(req
, status
);
3613 send_trans2_replies(conn
, req
,
3620 if (NT_STATUS_IS_OK(status
)) {
3621 /* Server-side transport
3622 * encryption is now *on*. */
3623 status
= srv_encryption_start(conn
);
3624 if (!NT_STATUS_IS_OK(status
)) {
3625 exit_server_cleanly(
3626 "Failure in setting "
3627 "up encrypted transport");
3633 case SMB_FS_QUOTA_INFORMATION
:
3635 files_struct
*fsp
= NULL
;
3636 SMB_NTQUOTA_STRUCT quotas
;
3638 ZERO_STRUCT(quotas
);
3641 if ((conn
->server_info
->utok
.uid
!= sec_initial_uid())
3642 ||!CAN_WRITE(conn
)) {
3643 DEBUG(0,("set_user_quota: access_denied service [%s] user [%s]\n",
3644 lp_servicename(SNUM(conn
)),
3645 conn
->server_info
->unix_name
));
3646 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
3650 /* note: normaly there're 48 bytes,
3651 * but we didn't use the last 6 bytes for now
3654 fsp
= file_fsp(req
, SVAL(params
,0));
3656 if (!check_fsp_ntquota_handle(conn
, req
,
3658 DEBUG(3,("TRANSACT_GET_USER_QUOTA: no valid QUOTA HANDLE\n"));
3660 req
, NT_STATUS_INVALID_HANDLE
);
3664 if (total_data
< 42) {
3665 DEBUG(0,("call_trans2setfsinfo: SET_FS_QUOTA: requires total_data(%d) >= 42 bytes!\n",
3669 NT_STATUS_INVALID_PARAMETER
);
3673 /* unknown_1 24 NULL bytes in pdata*/
3675 /* the soft quotas 8 bytes (uint64_t)*/
3676 quotas
.softlim
= (uint64_t)IVAL(pdata
,24);
3677 #ifdef LARGE_SMB_OFF_T
3678 quotas
.softlim
|= (((uint64_t)IVAL(pdata
,28)) << 32);
3679 #else /* LARGE_SMB_OFF_T */
3680 if ((IVAL(pdata
,28) != 0)&&
3681 ((quotas
.softlim
!= 0xFFFFFFFF)||
3682 (IVAL(pdata
,28)!=0xFFFFFFFF))) {
3683 /* more than 32 bits? */
3686 NT_STATUS_INVALID_PARAMETER
);
3689 #endif /* LARGE_SMB_OFF_T */
3691 /* the hard quotas 8 bytes (uint64_t)*/
3692 quotas
.hardlim
= (uint64_t)IVAL(pdata
,32);
3693 #ifdef LARGE_SMB_OFF_T
3694 quotas
.hardlim
|= (((uint64_t)IVAL(pdata
,36)) << 32);
3695 #else /* LARGE_SMB_OFF_T */
3696 if ((IVAL(pdata
,36) != 0)&&
3697 ((quotas
.hardlim
!= 0xFFFFFFFF)||
3698 (IVAL(pdata
,36)!=0xFFFFFFFF))) {
3699 /* more than 32 bits? */
3702 NT_STATUS_INVALID_PARAMETER
);
3705 #endif /* LARGE_SMB_OFF_T */
3707 /* quota_flags 2 bytes **/
3708 quotas
.qflags
= SVAL(pdata
,40);
3710 /* unknown_2 6 NULL bytes follow*/
3712 /* now set the quotas */
3713 if (vfs_set_ntquota(fsp
, SMB_USER_FS_QUOTA_TYPE
, NULL
, "as
)!=0) {
3714 DEBUG(0,("vfs_set_ntquota() failed for service [%s]\n",lp_servicename(SNUM(conn
))));
3715 reply_nterror(req
, map_nt_error_from_unix(errno
));
3722 DEBUG(3,("call_trans2setfsinfo: unknown level (0x%X) not implemented yet.\n",
3724 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
3730 * sending this reply works fine,
3731 * but I'm not sure it's the same
3732 * like windows do...
3735 reply_outbuf(req
, 10, 0);
3738 #if defined(HAVE_POSIX_ACLS)
3739 /****************************************************************************
3740 Utility function to count the number of entries in a POSIX acl.
3741 ****************************************************************************/
3743 static unsigned int count_acl_entries(connection_struct
*conn
, SMB_ACL_T posix_acl
)
3745 unsigned int ace_count
= 0;
3746 int entry_id
= SMB_ACL_FIRST_ENTRY
;
3747 SMB_ACL_ENTRY_T entry
;
3749 while ( posix_acl
&& (SMB_VFS_SYS_ACL_GET_ENTRY(conn
, posix_acl
, entry_id
, &entry
) == 1)) {
3751 if (entry_id
== SMB_ACL_FIRST_ENTRY
) {
3752 entry_id
= SMB_ACL_NEXT_ENTRY
;
3759 /****************************************************************************
3760 Utility function to marshall a POSIX acl into wire format.
3761 ****************************************************************************/
3763 static bool marshall_posix_acl(connection_struct
*conn
, char *pdata
, SMB_STRUCT_STAT
*pst
, SMB_ACL_T posix_acl
)
3765 int entry_id
= SMB_ACL_FIRST_ENTRY
;
3766 SMB_ACL_ENTRY_T entry
;
3768 while ( posix_acl
&& (SMB_VFS_SYS_ACL_GET_ENTRY(conn
, posix_acl
, entry_id
, &entry
) == 1)) {
3769 SMB_ACL_TAG_T tagtype
;
3770 SMB_ACL_PERMSET_T permset
;
3771 unsigned char perms
= 0;
3772 unsigned int own_grp
;
3775 if (entry_id
== SMB_ACL_FIRST_ENTRY
) {
3776 entry_id
= SMB_ACL_NEXT_ENTRY
;
3779 if (SMB_VFS_SYS_ACL_GET_TAG_TYPE(conn
, entry
, &tagtype
) == -1) {
3780 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_TAG_TYPE failed.\n"));
3784 if (SMB_VFS_SYS_ACL_GET_PERMSET(conn
, entry
, &permset
) == -1) {
3785 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_PERMSET failed.\n"));
3789 perms
|= (SMB_VFS_SYS_ACL_GET_PERM(conn
, permset
, SMB_ACL_READ
) ? SMB_POSIX_ACL_READ
: 0);
3790 perms
|= (SMB_VFS_SYS_ACL_GET_PERM(conn
, permset
, SMB_ACL_WRITE
) ? SMB_POSIX_ACL_WRITE
: 0);
3791 perms
|= (SMB_VFS_SYS_ACL_GET_PERM(conn
, permset
, SMB_ACL_EXECUTE
) ? SMB_POSIX_ACL_EXECUTE
: 0);
3793 SCVAL(pdata
,1,perms
);
3796 case SMB_ACL_USER_OBJ
:
3797 SCVAL(pdata
,0,SMB_POSIX_ACL_USER_OBJ
);
3798 own_grp
= (unsigned int)pst
->st_ex_uid
;
3799 SIVAL(pdata
,2,own_grp
);
3804 uid_t
*puid
= (uid_t
*)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn
, entry
);
3806 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3809 own_grp
= (unsigned int)*puid
;
3810 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn
, (void *)puid
,tagtype
);
3811 SCVAL(pdata
,0,SMB_POSIX_ACL_USER
);
3812 SIVAL(pdata
,2,own_grp
);
3816 case SMB_ACL_GROUP_OBJ
:
3817 SCVAL(pdata
,0,SMB_POSIX_ACL_GROUP_OBJ
);
3818 own_grp
= (unsigned int)pst
->st_ex_gid
;
3819 SIVAL(pdata
,2,own_grp
);
3824 gid_t
*pgid
= (gid_t
*)SMB_VFS_SYS_ACL_GET_QUALIFIER(conn
, entry
);
3826 DEBUG(0,("marshall_posix_acl: SMB_VFS_SYS_ACL_GET_QUALIFIER failed.\n"));
3829 own_grp
= (unsigned int)*pgid
;
3830 SMB_VFS_SYS_ACL_FREE_QUALIFIER(conn
, (void *)pgid
,tagtype
);
3831 SCVAL(pdata
,0,SMB_POSIX_ACL_GROUP
);
3832 SIVAL(pdata
,2,own_grp
);
3837 SCVAL(pdata
,0,SMB_POSIX_ACL_MASK
);
3838 SIVAL(pdata
,2,0xFFFFFFFF);
3839 SIVAL(pdata
,6,0xFFFFFFFF);
3842 SCVAL(pdata
,0,SMB_POSIX_ACL_OTHER
);
3843 SIVAL(pdata
,2,0xFFFFFFFF);
3844 SIVAL(pdata
,6,0xFFFFFFFF);
3847 DEBUG(0,("marshall_posix_acl: unknown tagtype.\n"));
3850 pdata
+= SMB_POSIX_ACL_ENTRY_SIZE
;
3857 /****************************************************************************
3858 Store the FILE_UNIX_BASIC info.
3859 ****************************************************************************/
3861 static char *store_file_unix_basic(connection_struct
*conn
,
3864 const SMB_STRUCT_STAT
*psbuf
)
3866 DEBUG(10,("store_file_unix_basic: SMB_QUERY_FILE_UNIX_BASIC\n"));
3867 DEBUG(4,("store_file_unix_basic: st_mode=%o\n",(int)psbuf
->st_ex_mode
));
3869 SOFF_T(pdata
,0,get_file_size_stat(psbuf
)); /* File size 64 Bit */
3872 SOFF_T(pdata
,0,SMB_VFS_GET_ALLOC_SIZE(conn
,fsp
,psbuf
)); /* Number of bytes used on disk - 64 Bit */
3875 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER
, pdata
, psbuf
->st_ex_ctime
); /* Change Time 64 Bit */
3876 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER
,pdata
+8, psbuf
->st_ex_atime
); /* Last access time 64 Bit */
3877 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER
, pdata
+16, psbuf
->st_ex_mtime
); /* Last modification time 64 Bit */
3880 SIVAL(pdata
,0,psbuf
->st_ex_uid
); /* user id for the owner */
3884 SIVAL(pdata
,0,psbuf
->st_ex_gid
); /* group id of owner */
3888 SIVAL(pdata
,0,unix_filetype(psbuf
->st_ex_mode
));
3891 SIVAL(pdata
,0,unix_dev_major(psbuf
->st_ex_rdev
)); /* Major device number if type is device */
3895 SIVAL(pdata
,0,unix_dev_minor(psbuf
->st_ex_rdev
)); /* Minor device number if type is device */
3899 SINO_T_VAL(pdata
,0,(SMB_INO_T
)psbuf
->st_ex_ino
); /* inode number */
3902 SIVAL(pdata
,0, unix_perms_to_wire(psbuf
->st_ex_mode
)); /* Standard UNIX file permissions */
3906 SIVAL(pdata
,0,psbuf
->st_ex_nlink
); /* number of hard links */
3913 /* Forward and reverse mappings from the UNIX_INFO2 file flags field and
3914 * the chflags(2) (or equivalent) flags.
3916 * XXX: this really should be behind the VFS interface. To do this, we would
3917 * need to alter SMB_STRUCT_STAT so that it included a flags and a mask field.
3918 * Each VFS module could then implement its own mapping as appropriate for the
3919 * platform. We would then pass the SMB flags into SMB_VFS_CHFLAGS.
3921 static const struct {unsigned stat_fflag
; unsigned smb_fflag
;}
3925 { UF_NODUMP
, EXT_DO_NOT_BACKUP
},
3929 { UF_IMMUTABLE
, EXT_IMMUTABLE
},
3933 { UF_APPEND
, EXT_OPEN_APPEND_ONLY
},
3937 { UF_HIDDEN
, EXT_HIDDEN
},
3940 /* Do not remove. We need to guarantee that this array has at least one
3941 * entry to build on HP-UX.
3947 static void map_info2_flags_from_sbuf(const SMB_STRUCT_STAT
*psbuf
,
3948 uint32
*smb_fflags
, uint32
*smb_fmask
)
3952 for (i
= 0; i
< ARRAY_SIZE(info2_flags_map
); ++i
) {
3953 *smb_fmask
|= info2_flags_map
[i
].smb_fflag
;
3954 if (psbuf
->st_ex_flags
& info2_flags_map
[i
].stat_fflag
) {
3955 *smb_fflags
|= info2_flags_map
[i
].smb_fflag
;
3960 static bool map_info2_flags_to_sbuf(const SMB_STRUCT_STAT
*psbuf
,
3961 const uint32 smb_fflags
,
3962 const uint32 smb_fmask
,
3965 uint32 max_fmask
= 0;
3968 *stat_fflags
= psbuf
->st_ex_flags
;
3970 /* For each flags requested in smb_fmask, check the state of the
3971 * corresponding flag in smb_fflags and set or clear the matching
3975 for (i
= 0; i
< ARRAY_SIZE(info2_flags_map
); ++i
) {
3976 max_fmask
|= info2_flags_map
[i
].smb_fflag
;
3977 if (smb_fmask
& info2_flags_map
[i
].smb_fflag
) {
3978 if (smb_fflags
& info2_flags_map
[i
].smb_fflag
) {
3979 *stat_fflags
|= info2_flags_map
[i
].stat_fflag
;
3981 *stat_fflags
&= ~info2_flags_map
[i
].stat_fflag
;
3986 /* If smb_fmask is asking to set any bits that are not supported by
3987 * our flag mappings, we should fail.
3989 if ((smb_fmask
& max_fmask
) != smb_fmask
) {
3997 /* Just like SMB_QUERY_FILE_UNIX_BASIC, but with the addition
3998 * of file flags and birth (create) time.
4000 static char *store_file_unix_basic_info2(connection_struct
*conn
,
4003 const SMB_STRUCT_STAT
*psbuf
)
4005 uint32 file_flags
= 0;
4006 uint32 flags_mask
= 0;
4008 pdata
= store_file_unix_basic(conn
, pdata
, fsp
, psbuf
);
4010 /* Create (birth) time 64 bit */
4011 put_long_date_timespec(TIMESTAMP_SET_NT_OR_BETTER
,pdata
, psbuf
->st_ex_btime
);
4014 map_info2_flags_from_sbuf(psbuf
, &file_flags
, &flags_mask
);
4015 SIVAL(pdata
, 0, file_flags
); /* flags */
4016 SIVAL(pdata
, 4, flags_mask
); /* mask */
4022 static NTSTATUS
marshall_stream_info(unsigned int num_streams
,
4023 const struct stream_struct
*streams
,
4025 unsigned int max_data_bytes
,
4026 unsigned int *data_size
)
4029 unsigned int ofs
= 0;
4031 for (i
= 0; i
< num_streams
&& ofs
<= max_data_bytes
; i
++) {
4032 unsigned int next_offset
;
4034 smb_ucs2_t
*namebuf
;
4036 if (!push_ucs2_talloc(talloc_tos(), &namebuf
,
4037 streams
[i
].name
, &namelen
) ||
4040 return NT_STATUS_INVALID_PARAMETER
;
4044 * name_buf is now null-terminated, we need to marshall as not
4050 SIVAL(data
, ofs
+4, namelen
);
4051 SOFF_T(data
, ofs
+8, streams
[i
].size
);
4052 SOFF_T(data
, ofs
+16, streams
[i
].alloc_size
);
4053 memcpy(data
+ofs
+24, namebuf
, namelen
);
4054 TALLOC_FREE(namebuf
);
4056 next_offset
= ofs
+ 24 + namelen
;
4058 if (i
== num_streams
-1) {
4059 SIVAL(data
, ofs
, 0);
4062 unsigned int align
= ndr_align_size(next_offset
, 8);
4064 memset(data
+next_offset
, 0, align
);
4065 next_offset
+= align
;
4067 SIVAL(data
, ofs
, next_offset
- ofs
);
4076 return NT_STATUS_OK
;
4079 /****************************************************************************
4080 Reply to a TRANSACT2_QFILEINFO on a PIPE !
4081 ****************************************************************************/
4083 static void call_trans2qpipeinfo(connection_struct
*conn
,
4084 struct smb_request
*req
,
4085 unsigned int tran_call
,
4086 char **pparams
, int total_params
,
4087 char **ppdata
, int total_data
,
4088 unsigned int max_data_bytes
)
4090 char *params
= *pparams
;
4091 char *pdata
= *ppdata
;
4092 unsigned int data_size
= 0;
4093 unsigned int param_size
= 2;
4098 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
4102 if (total_params
< 4) {
4103 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
4107 fsp
= file_fsp(req
, SVAL(params
,0));
4108 if (!fsp_is_np(fsp
)) {
4109 reply_nterror(req
, NT_STATUS_INVALID_HANDLE
);
4113 info_level
= SVAL(params
,2);
4115 *pparams
= (char *)SMB_REALLOC(*pparams
,2);
4116 if (*pparams
== NULL
) {
4117 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
4122 data_size
= max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
;
4123 *ppdata
= (char *)SMB_REALLOC(*ppdata
, data_size
);
4124 if (*ppdata
== NULL
) {
4125 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
4130 switch (info_level
) {
4131 case SMB_FILE_STANDARD_INFORMATION
:
4133 SOFF_T(pdata
,0,4096LL);
4140 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
4144 send_trans2_replies(conn
, req
, params
, param_size
, *ppdata
, data_size
,
4150 NTSTATUS
smbd_do_qfilepathinfo(connection_struct
*conn
,
4151 TALLOC_CTX
*mem_ctx
,
4152 uint16_t info_level
,
4154 struct smb_filename
*smb_fname
,
4155 bool delete_pending
,
4156 struct timespec write_time_ts
,
4158 struct ea_list
*ea_list
,
4159 int lock_data_count
,
4162 unsigned int max_data_bytes
,
4164 unsigned int *pdata_size
)
4166 char *pdata
= *ppdata
;
4167 char *dstart
, *dend
;
4168 unsigned int data_size
;
4169 struct timespec create_time_ts
, mtime_ts
, atime_ts
, ctime_ts
;
4170 time_t create_time
, mtime
, atime
, c_time
;
4171 SMB_STRUCT_STAT
*psbuf
= &smb_fname
->st
;
4178 uint64_t file_size
= 0;
4180 uint64_t allocation_size
= 0;
4181 uint64_t file_index
= 0;
4182 uint32_t access_mask
= 0;
4184 if (INFO_LEVEL_IS_UNIX(info_level
) && !lp_unix_extensions()) {
4185 return NT_STATUS_INVALID_LEVEL
;
4188 DEBUG(5,("smbd_do_qfilepathinfo: %s (fnum = %d) level=%d max_data=%u\n",
4189 smb_fname_str_dbg(smb_fname
), fsp
? fsp
->fnum
: -1,
4190 info_level
, max_data_bytes
));
4193 mode
= dos_mode_msdfs(conn
, smb_fname
);
4195 mode
= dos_mode(conn
, smb_fname
);
4198 nlink
= psbuf
->st_ex_nlink
;
4200 if (nlink
&& (mode
&aDIR
)) {
4204 if ((nlink
> 0) && delete_pending
) {
4208 data_size
= max_data_bytes
+ DIR_ENTRY_SAFETY_MARGIN
;
4209 *ppdata
= (char *)SMB_REALLOC(*ppdata
, data_size
);
4210 if (*ppdata
== NULL
) {
4211 return NT_STATUS_NO_MEMORY
;
4215 dend
= dstart
+ data_size
- 1;
4217 if (!null_timespec(write_time_ts
) && !INFO_LEVEL_IS_UNIX(info_level
)) {
4218 update_stat_ex_mtime(psbuf
, write_time_ts
);
4221 create_time_ts
= get_create_timespec(conn
, fsp
, smb_fname
);
4222 mtime_ts
= psbuf
->st_ex_mtime
;
4223 atime_ts
= psbuf
->st_ex_atime
;
4224 ctime_ts
= get_change_timespec(conn
, fsp
, smb_fname
);
4226 if (lp_dos_filetime_resolution(SNUM(conn
))) {
4227 dos_filetime_timespec(&create_time_ts
);
4228 dos_filetime_timespec(&mtime_ts
);
4229 dos_filetime_timespec(&atime_ts
);
4230 dos_filetime_timespec(&ctime_ts
);
4233 create_time
= convert_timespec_to_time_t(create_time_ts
);
4234 mtime
= convert_timespec_to_time_t(mtime_ts
);
4235 atime
= convert_timespec_to_time_t(atime_ts
);
4236 c_time
= convert_timespec_to_time_t(ctime_ts
);
4238 p
= strrchr_m(smb_fname
->base_name
,'/');
4240 base_name
= smb_fname
->base_name
;
4244 /* NT expects the name to be in an exact form of the *full*
4245 filename. See the trans2 torture test */
4246 if (ISDOT(base_name
)) {
4247 dos_fname
= talloc_strdup(mem_ctx
, "\\");
4249 return NT_STATUS_NO_MEMORY
;
4252 dos_fname
= talloc_asprintf(mem_ctx
,
4254 smb_fname
->base_name
);
4256 return NT_STATUS_NO_MEMORY
;
4258 if (is_ntfs_stream_smb_fname(smb_fname
)) {
4259 dos_fname
= talloc_asprintf(dos_fname
, "%s",
4260 smb_fname
->stream_name
);
4262 return NT_STATUS_NO_MEMORY
;
4266 string_replace(dos_fname
, '/', '\\');
4269 allocation_size
= SMB_VFS_GET_ALLOC_SIZE(conn
, fsp
, psbuf
);
4272 /* Do we have this path open ? */
4274 struct file_id fileid
= vfs_file_id_from_sbuf(conn
, psbuf
);
4275 fsp1
= file_find_di_first(fileid
);
4276 if (fsp1
&& fsp1
->initial_allocation_size
) {
4277 allocation_size
= SMB_VFS_GET_ALLOC_SIZE(conn
, fsp1
, psbuf
);
4281 if (!(mode
& aDIR
)) {
4282 file_size
= get_file_size_stat(psbuf
);
4286 pos
= fsp
->fh
->position_information
;
4290 access_mask
= fsp
->access_mask
;
4292 /* GENERIC_EXECUTE mapping from Windows */
4293 access_mask
= 0x12019F;
4296 /* This should be an index number - looks like
4299 I think this causes us to fail the IFSKIT
4300 BasicFileInformationTest. -tpot */
4301 file_index
= ((psbuf
->st_ex_ino
) & UINT32_MAX
); /* FileIndexLow */
4302 file_index
|= ((uint64_t)((psbuf
->st_ex_dev
) & UINT32_MAX
)) << 32; /* FileIndexHigh */
4304 switch (info_level
) {
4305 case SMB_INFO_STANDARD
:
4306 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_STANDARD\n"));
4308 srv_put_dos_date2(pdata
,l1_fdateCreation
,create_time
);
4309 srv_put_dos_date2(pdata
,l1_fdateLastAccess
,atime
);
4310 srv_put_dos_date2(pdata
,l1_fdateLastWrite
,mtime
); /* write time */
4311 SIVAL(pdata
,l1_cbFile
,(uint32
)file_size
);
4312 SIVAL(pdata
,l1_cbFileAlloc
,(uint32
)allocation_size
);
4313 SSVAL(pdata
,l1_attrFile
,mode
);
4316 case SMB_INFO_QUERY_EA_SIZE
:
4318 unsigned int ea_size
=
4319 estimate_ea_size(conn
, fsp
,
4320 smb_fname
->base_name
);
4321 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EA_SIZE\n"));
4323 srv_put_dos_date2(pdata
,0,create_time
);
4324 srv_put_dos_date2(pdata
,4,atime
);
4325 srv_put_dos_date2(pdata
,8,mtime
); /* write time */
4326 SIVAL(pdata
,12,(uint32
)file_size
);
4327 SIVAL(pdata
,16,(uint32
)allocation_size
);
4328 SSVAL(pdata
,20,mode
);
4329 SIVAL(pdata
,22,ea_size
);
4333 case SMB_INFO_IS_NAME_VALID
:
4334 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_IS_NAME_VALID\n"));
4336 /* os/2 needs this ? really ?*/
4337 return NT_STATUS_DOS(ERRDOS
, ERRbadfunc
);
4339 /* This is only reached for qpathinfo */
4343 case SMB_INFO_QUERY_EAS_FROM_LIST
:
4345 size_t total_ea_len
= 0;
4346 struct ea_list
*ea_file_list
= NULL
;
4348 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_EAS_FROM_LIST\n"));
4351 get_ea_list_from_file(mem_ctx
, conn
, fsp
,
4352 smb_fname
->base_name
,
4354 ea_list
= ea_list_union(ea_list
, ea_file_list
, &total_ea_len
);
4356 if (!ea_list
|| (total_ea_len
> data_size
)) {
4358 SIVAL(pdata
,0,4); /* EA List Length must be set to 4 if no EA's. */
4362 data_size
= fill_ea_buffer(mem_ctx
, pdata
, data_size
, conn
, ea_list
);
4366 case SMB_INFO_QUERY_ALL_EAS
:
4368 /* We have data_size bytes to put EA's into. */
4369 size_t total_ea_len
= 0;
4371 DEBUG(10,("smbd_do_qfilepathinfo: SMB_INFO_QUERY_ALL_EAS\n"));
4373 ea_list
= get_ea_list_from_file(mem_ctx
, conn
, fsp
,
4374 smb_fname
->base_name
,
4376 if (!ea_list
|| (total_ea_len
> data_size
)) {
4378 SIVAL(pdata
,0,4); /* EA List Length must be set to 4 if no EA's. */
4382 data_size
= fill_ea_buffer(mem_ctx
, pdata
, data_size
, conn
, ea_list
);
4386 case 0xFF0F:/*SMB2_INFO_QUERY_ALL_EAS*/
4388 /* This is FileFullEaInformation - 0xF which maps to
4389 * 1015 (decimal) in smbd_do_setfilepathinfo. */
4391 /* We have data_size bytes to put EA's into. */
4392 size_t total_ea_len
= 0;
4393 struct ea_list
*ea_file_list
= NULL
;
4395 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_INFO_QUERY_ALL_EAS\n"));
4397 /*TODO: add filtering and index handling */
4400 get_ea_list_from_file(mem_ctx
, conn
, fsp
,
4401 smb_fname
->base_name
,
4403 if (!ea_file_list
) {
4404 return NT_STATUS_NO_EAS_ON_FILE
;
4407 status
= fill_ea_chained_buffer(mem_ctx
,
4411 conn
, ea_file_list
);
4412 if (!NT_STATUS_IS_OK(status
)) {
4418 case SMB_FILE_BASIC_INFORMATION
:
4419 case SMB_QUERY_FILE_BASIC_INFO
:
4421 if (info_level
== SMB_QUERY_FILE_BASIC_INFO
) {
4422 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_BASIC_INFO\n"));
4423 data_size
= 36; /* w95 returns 40 bytes not 36 - why ?. */
4425 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_BASIC_INFORMATION\n"));
4429 put_long_date_timespec(conn
->ts_res
,pdata
,create_time_ts
);
4430 put_long_date_timespec(conn
->ts_res
,pdata
+8,atime_ts
);
4431 put_long_date_timespec(conn
->ts_res
,pdata
+16,mtime_ts
); /* write time */
4432 put_long_date_timespec(conn
->ts_res
,pdata
+24,ctime_ts
); /* change time */
4433 SIVAL(pdata
,32,mode
);
4435 DEBUG(5,("SMB_QFBI - "));
4436 DEBUG(5,("create: %s ", ctime(&create_time
)));
4437 DEBUG(5,("access: %s ", ctime(&atime
)));
4438 DEBUG(5,("write: %s ", ctime(&mtime
)));
4439 DEBUG(5,("change: %s ", ctime(&c_time
)));
4440 DEBUG(5,("mode: %x\n", mode
));
4443 case SMB_FILE_STANDARD_INFORMATION
:
4444 case SMB_QUERY_FILE_STANDARD_INFO
:
4446 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_STANDARD_INFORMATION\n"));
4448 SOFF_T(pdata
,0,allocation_size
);
4449 SOFF_T(pdata
,8,file_size
);
4450 SIVAL(pdata
,16,nlink
);
4451 SCVAL(pdata
,20,delete_pending
?1:0);
4452 SCVAL(pdata
,21,(mode
&aDIR
)?1:0);
4453 SSVAL(pdata
,22,0); /* Padding. */
4456 case SMB_FILE_EA_INFORMATION
:
4457 case SMB_QUERY_FILE_EA_INFO
:
4459 unsigned int ea_size
=
4460 estimate_ea_size(conn
, fsp
, smb_fname
->base_name
);
4461 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_EA_INFORMATION\n"));
4463 SIVAL(pdata
,0,ea_size
);
4467 /* Get the 8.3 name - used if NT SMB was negotiated. */
4468 case SMB_QUERY_FILE_ALT_NAME_INFO
:
4469 case SMB_FILE_ALTERNATE_NAME_INFORMATION
:
4472 char mangled_name
[13];
4473 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALTERNATE_NAME_INFORMATION\n"));
4474 if (!name_to_8_3(base_name
,mangled_name
,
4475 True
,conn
->params
)) {
4476 return NT_STATUS_NO_MEMORY
;
4478 len
= srvstr_push(dstart
, flags2
,
4479 pdata
+4, mangled_name
,
4480 PTR_DIFF(dend
, pdata
+4),
4482 data_size
= 4 + len
;
4487 case SMB_QUERY_FILE_NAME_INFO
:
4491 this must be *exactly* right for ACLs on mapped drives to work
4493 len
= srvstr_push(dstart
, flags2
,
4495 PTR_DIFF(dend
, pdata
+4),
4497 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_NAME_INFO\n"));
4498 data_size
= 4 + len
;
4503 case SMB_FILE_ALLOCATION_INFORMATION
:
4504 case SMB_QUERY_FILE_ALLOCATION_INFO
:
4505 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALLOCATION_INFORMATION\n"));
4507 SOFF_T(pdata
,0,allocation_size
);
4510 case SMB_FILE_END_OF_FILE_INFORMATION
:
4511 case SMB_QUERY_FILE_END_OF_FILEINFO
:
4512 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_END_OF_FILE_INFORMATION\n"));
4514 SOFF_T(pdata
,0,file_size
);
4517 case SMB_QUERY_FILE_ALL_INFO
:
4518 case SMB_FILE_ALL_INFORMATION
:
4521 unsigned int ea_size
=
4522 estimate_ea_size(conn
, fsp
, smb_fname
->base_name
);
4523 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALL_INFORMATION\n"));
4524 put_long_date_timespec(conn
->ts_res
,pdata
,create_time_ts
);
4525 put_long_date_timespec(conn
->ts_res
,pdata
+8,atime_ts
);
4526 put_long_date_timespec(conn
->ts_res
,pdata
+16,mtime_ts
); /* write time */
4527 put_long_date_timespec(conn
->ts_res
,pdata
+24,ctime_ts
); /* change time */
4528 SIVAL(pdata
,32,mode
);
4529 SIVAL(pdata
,36,0); /* padding. */
4531 SOFF_T(pdata
,0,allocation_size
);
4532 SOFF_T(pdata
,8,file_size
);
4533 SIVAL(pdata
,16,nlink
);
4534 SCVAL(pdata
,20,delete_pending
);
4535 SCVAL(pdata
,21,(mode
&aDIR
)?1:0);
4538 SIVAL(pdata
,0,ea_size
);
4539 pdata
+= 4; /* EA info */
4540 len
= srvstr_push(dstart
, flags2
,
4542 PTR_DIFF(dend
, pdata
+4),
4546 data_size
= PTR_DIFF(pdata
,(*ppdata
));
4550 case 0xFF12:/*SMB2_FILE_ALL_INFORMATION*/
4553 unsigned int ea_size
=
4554 estimate_ea_size(conn
, fsp
, smb_fname
->base_name
);
4555 DEBUG(10,("smbd_do_qfilepathinfo: SMB2_FILE_ALL_INFORMATION\n"));
4556 put_long_date_timespec(conn
->ts_res
,pdata
+0x00,create_time_ts
);
4557 put_long_date_timespec(conn
->ts_res
,pdata
+0x08,atime_ts
);
4558 put_long_date_timespec(conn
->ts_res
,pdata
+0x10,mtime_ts
); /* write time */
4559 put_long_date_timespec(conn
->ts_res
,pdata
+0x18,ctime_ts
); /* change time */
4560 SIVAL(pdata
, 0x20, mode
);
4561 SIVAL(pdata
, 0x24, 0); /* padding. */
4562 SBVAL(pdata
, 0x28, allocation_size
);
4563 SBVAL(pdata
, 0x30, file_size
);
4564 SIVAL(pdata
, 0x38, nlink
);
4565 SCVAL(pdata
, 0x3C, delete_pending
);
4566 SCVAL(pdata
, 0x3D, (mode
&aDIR
)?1:0);
4567 SSVAL(pdata
, 0x3E, 0); /* padding */
4568 SBVAL(pdata
, 0x40, file_index
);
4569 SIVAL(pdata
, 0x48, ea_size
);
4570 SIVAL(pdata
, 0x4C, access_mask
);
4571 SBVAL(pdata
, 0x50, pos
);
4572 SIVAL(pdata
, 0x58, mode
); /*TODO: mode != mode fix this!!! */
4573 SIVAL(pdata
, 0x5C, 0); /* No alignment needed. */
4577 len
= srvstr_push(dstart
, flags2
,
4579 PTR_DIFF(dend
, pdata
+4),
4583 data_size
= PTR_DIFF(pdata
,(*ppdata
));
4586 case SMB_FILE_INTERNAL_INFORMATION
:
4588 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_INTERNAL_INFORMATION\n"));
4589 SBVAL(pdata
, 0, file_index
);
4593 case SMB_FILE_ACCESS_INFORMATION
:
4594 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ACCESS_INFORMATION\n"));
4595 SIVAL(pdata
, 0, access_mask
);
4599 case SMB_FILE_NAME_INFORMATION
:
4600 /* Pathname with leading '\'. */
4603 byte_len
= dos_PutUniCode(pdata
+4,dos_fname
,(size_t)max_data_bytes
,False
);
4604 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NAME_INFORMATION\n"));
4605 SIVAL(pdata
,0,byte_len
);
4606 data_size
= 4 + byte_len
;
4610 case SMB_FILE_DISPOSITION_INFORMATION
:
4611 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_DISPOSITION_INFORMATION\n"));
4613 SCVAL(pdata
,0,delete_pending
);
4616 case SMB_FILE_POSITION_INFORMATION
:
4617 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_POSITION_INFORMATION\n"));
4619 SOFF_T(pdata
,0,pos
);
4622 case SMB_FILE_MODE_INFORMATION
:
4623 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_MODE_INFORMATION\n"));
4624 SIVAL(pdata
,0,mode
);
4628 case SMB_FILE_ALIGNMENT_INFORMATION
:
4629 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ALIGNMENT_INFORMATION\n"));
4630 SIVAL(pdata
,0,0); /* No alignment needed. */
4635 * NT4 server just returns "invalid query" to this - if we try
4636 * to answer it then NTws gets a BSOD! (tridge). W2K seems to
4639 /* The first statement above is false - verified using Thursby
4640 * client against NT4 -- gcolley.
4642 case SMB_QUERY_FILE_STREAM_INFO
:
4643 case SMB_FILE_STREAM_INFORMATION
: {
4644 unsigned int num_streams
;
4645 struct stream_struct
*streams
;
4647 DEBUG(10,("smbd_do_qfilepathinfo: "
4648 "SMB_FILE_STREAM_INFORMATION\n"));
4650 if (is_ntfs_stream_smb_fname(smb_fname
)) {
4651 return NT_STATUS_INVALID_PARAMETER
;
4654 status
= SMB_VFS_STREAMINFO(
4655 conn
, fsp
, smb_fname
->base_name
, talloc_tos(),
4656 &num_streams
, &streams
);
4658 if (!NT_STATUS_IS_OK(status
)) {
4659 DEBUG(10, ("could not get stream info: %s\n",
4660 nt_errstr(status
)));
4664 status
= marshall_stream_info(num_streams
, streams
,
4665 pdata
, max_data_bytes
,
4668 if (!NT_STATUS_IS_OK(status
)) {
4669 DEBUG(10, ("marshall_stream_info failed: %s\n",
4670 nt_errstr(status
)));
4674 TALLOC_FREE(streams
);
4678 case SMB_QUERY_COMPRESSION_INFO
:
4679 case SMB_FILE_COMPRESSION_INFORMATION
:
4680 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_COMPRESSION_INFORMATION\n"));
4681 SOFF_T(pdata
,0,file_size
);
4682 SIVAL(pdata
,8,0); /* ??? */
4683 SIVAL(pdata
,12,0); /* ??? */
4687 case SMB_FILE_NETWORK_OPEN_INFORMATION
:
4688 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_NETWORK_OPEN_INFORMATION\n"));
4689 put_long_date_timespec(conn
->ts_res
,pdata
,create_time_ts
);
4690 put_long_date_timespec(conn
->ts_res
,pdata
+8,atime_ts
);
4691 put_long_date_timespec(conn
->ts_res
,pdata
+16,mtime_ts
); /* write time */
4692 put_long_date_timespec(conn
->ts_res
,pdata
+24,ctime_ts
); /* change time */
4693 SOFF_T(pdata
,32,allocation_size
);
4694 SOFF_T(pdata
,40,file_size
);
4695 SIVAL(pdata
,48,mode
);
4696 SIVAL(pdata
,52,0); /* ??? */
4700 case SMB_FILE_ATTRIBUTE_TAG_INFORMATION
:
4701 DEBUG(10,("smbd_do_qfilepathinfo: SMB_FILE_ATTRIBUTE_TAG_INFORMATION\n"));
4702 SIVAL(pdata
,0,mode
);
4708 * CIFS UNIX Extensions.
4711 case SMB_QUERY_FILE_UNIX_BASIC
:
4713 pdata
= store_file_unix_basic(conn
, pdata
, fsp
, psbuf
);
4714 data_size
= PTR_DIFF(pdata
,(*ppdata
));
4718 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_BASIC "));
4720 for (i
=0; i
<100; i
++)
4721 DEBUG(4,("%d=%x, ",i
, (*ppdata
)[i
]));
4727 case SMB_QUERY_FILE_UNIX_INFO2
:
4729 pdata
= store_file_unix_basic_info2(conn
, pdata
, fsp
, psbuf
);
4730 data_size
= PTR_DIFF(pdata
,(*ppdata
));
4734 DEBUG(4,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_INFO2 "));
4736 for (i
=0; i
<100; i
++)
4737 DEBUG(4,("%d=%x, ",i
, (*ppdata
)[i
]));
4743 case SMB_QUERY_FILE_UNIX_LINK
:
4746 char *buffer
= TALLOC_ARRAY(mem_ctx
, char, PATH_MAX
+1);
4749 return NT_STATUS_NO_MEMORY
;
4752 DEBUG(10,("smbd_do_qfilepathinfo: SMB_QUERY_FILE_UNIX_LINK\n"));
4754 if(!S_ISLNK(psbuf
->st_ex_mode
)) {
4755 return NT_STATUS_DOS(ERRSRV
, ERRbadlink
);
4758 return NT_STATUS_DOS(ERRDOS
, ERRbadlink
);
4760 len
= SMB_VFS_READLINK(conn
,
4761 smb_fname
->base_name
,
4764 return map_nt_error_from_unix(errno
);
4767 len
= srvstr_push(dstart
, flags2
,
4769 PTR_DIFF(dend
, pdata
),
4772 data_size
= PTR_DIFF(pdata
,(*ppdata
));
4777 #if defined(HAVE_POSIX_ACLS)
4778 case SMB_QUERY_POSIX_ACL
:
4780 SMB_ACL_T file_acl
= NULL
;
4781 SMB_ACL_T def_acl
= NULL
;
4782 uint16 num_file_acls
= 0;
4783 uint16 num_def_acls
= 0;
4785 if (fsp
&& !fsp
->is_directory
&& (fsp
->fh
->fd
!= -1)) {
4786 file_acl
= SMB_VFS_SYS_ACL_GET_FD(fsp
);
4789 SMB_VFS_SYS_ACL_GET_FILE(conn
,
4790 smb_fname
->base_name
,
4791 SMB_ACL_TYPE_ACCESS
);
4794 if (file_acl
== NULL
&& no_acl_syscall_error(errno
)) {
4795 DEBUG(5,("smbd_do_qfilepathinfo: ACLs "
4796 "not implemented on "
4797 "filesystem containing %s\n",
4798 smb_fname
->base_name
));
4799 return NT_STATUS_NOT_IMPLEMENTED
;
4802 if (S_ISDIR(psbuf
->st_ex_mode
)) {
4803 if (fsp
&& fsp
->is_directory
) {
4805 SMB_VFS_SYS_ACL_GET_FILE(
4807 fsp
->fsp_name
->base_name
,
4808 SMB_ACL_TYPE_DEFAULT
);
4811 SMB_VFS_SYS_ACL_GET_FILE(
4813 smb_fname
->base_name
,
4814 SMB_ACL_TYPE_DEFAULT
);
4816 def_acl
= free_empty_sys_acl(conn
, def_acl
);
4819 num_file_acls
= count_acl_entries(conn
, file_acl
);
4820 num_def_acls
= count_acl_entries(conn
, def_acl
);
4822 if ( data_size
< (num_file_acls
+ num_def_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
+ SMB_POSIX_ACL_HEADER_SIZE
) {
4823 DEBUG(5,("smbd_do_qfilepathinfo: data_size too small (%u) need %u\n",
4825 (unsigned int)((num_file_acls
+ num_def_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
+
4826 SMB_POSIX_ACL_HEADER_SIZE
) ));
4828 SMB_VFS_SYS_ACL_FREE_ACL(conn
, file_acl
);
4831 SMB_VFS_SYS_ACL_FREE_ACL(conn
, def_acl
);
4833 return NT_STATUS_BUFFER_TOO_SMALL
;
4836 SSVAL(pdata
,0,SMB_POSIX_ACL_VERSION
);
4837 SSVAL(pdata
,2,num_file_acls
);
4838 SSVAL(pdata
,4,num_def_acls
);
4839 if (!marshall_posix_acl(conn
, pdata
+ SMB_POSIX_ACL_HEADER_SIZE
, psbuf
, file_acl
)) {
4841 SMB_VFS_SYS_ACL_FREE_ACL(conn
, file_acl
);
4844 SMB_VFS_SYS_ACL_FREE_ACL(conn
, def_acl
);
4846 return NT_STATUS_INTERNAL_ERROR
;
4848 if (!marshall_posix_acl(conn
, pdata
+ SMB_POSIX_ACL_HEADER_SIZE
+ (num_file_acls
*SMB_POSIX_ACL_ENTRY_SIZE
), psbuf
, def_acl
)) {
4850 SMB_VFS_SYS_ACL_FREE_ACL(conn
, file_acl
);
4853 SMB_VFS_SYS_ACL_FREE_ACL(conn
, def_acl
);
4855 return NT_STATUS_INTERNAL_ERROR
;
4859 SMB_VFS_SYS_ACL_FREE_ACL(conn
, file_acl
);
4862 SMB_VFS_SYS_ACL_FREE_ACL(conn
, def_acl
);
4864 data_size
= (num_file_acls
+ num_def_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
+ SMB_POSIX_ACL_HEADER_SIZE
;
4870 case SMB_QUERY_POSIX_LOCK
:
4875 enum brl_type lock_type
;
4877 /* We need an open file with a real fd for this. */
4878 if (!fsp
|| fsp
->is_directory
|| fsp
->fh
->fd
== -1) {
4879 return NT_STATUS_INVALID_LEVEL
;
4882 if (lock_data_count
!= POSIX_LOCK_DATA_SIZE
) {
4883 return NT_STATUS_INVALID_PARAMETER
;
4886 switch (SVAL(pdata
, POSIX_LOCK_TYPE_OFFSET
)) {
4887 case POSIX_LOCK_TYPE_READ
:
4888 lock_type
= READ_LOCK
;
4890 case POSIX_LOCK_TYPE_WRITE
:
4891 lock_type
= WRITE_LOCK
;
4893 case POSIX_LOCK_TYPE_UNLOCK
:
4895 /* There's no point in asking for an unlock... */
4896 return NT_STATUS_INVALID_PARAMETER
;
4899 lock_pid
= IVAL(pdata
, POSIX_LOCK_PID_OFFSET
);
4900 #if defined(HAVE_LONGLONG)
4901 offset
= (((uint64_t) IVAL(pdata
,(POSIX_LOCK_START_OFFSET
+4))) << 32) |
4902 ((uint64_t) IVAL(pdata
,POSIX_LOCK_START_OFFSET
));
4903 count
= (((uint64_t) IVAL(pdata
,(POSIX_LOCK_LEN_OFFSET
+4))) << 32) |
4904 ((uint64_t) IVAL(pdata
,POSIX_LOCK_LEN_OFFSET
));
4905 #else /* HAVE_LONGLONG */
4906 offset
= (uint64_t)IVAL(pdata
,POSIX_LOCK_START_OFFSET
);
4907 count
= (uint64_t)IVAL(pdata
,POSIX_LOCK_LEN_OFFSET
);
4908 #endif /* HAVE_LONGLONG */
4910 status
= query_lock(fsp
,
4917 if (ERROR_WAS_LOCK_DENIED(status
)) {
4918 /* Here we need to report who has it locked... */
4919 data_size
= POSIX_LOCK_DATA_SIZE
;
4921 SSVAL(pdata
, POSIX_LOCK_TYPE_OFFSET
, lock_type
);
4922 SSVAL(pdata
, POSIX_LOCK_FLAGS_OFFSET
, 0);
4923 SIVAL(pdata
, POSIX_LOCK_PID_OFFSET
, lock_pid
);
4924 #if defined(HAVE_LONGLONG)
4925 SIVAL(pdata
, POSIX_LOCK_START_OFFSET
, (uint32
)(offset
& 0xFFFFFFFF));
4926 SIVAL(pdata
, POSIX_LOCK_START_OFFSET
+ 4, (uint32
)((offset
>> 32) & 0xFFFFFFFF));
4927 SIVAL(pdata
, POSIX_LOCK_LEN_OFFSET
, (uint32
)(count
& 0xFFFFFFFF));
4928 SIVAL(pdata
, POSIX_LOCK_LEN_OFFSET
+ 4, (uint32
)((count
>> 32) & 0xFFFFFFFF));
4929 #else /* HAVE_LONGLONG */
4930 SIVAL(pdata
, POSIX_LOCK_START_OFFSET
, offset
);
4931 SIVAL(pdata
, POSIX_LOCK_LEN_OFFSET
, count
);
4932 #endif /* HAVE_LONGLONG */
4934 } else if (NT_STATUS_IS_OK(status
)) {
4935 /* For success we just return a copy of what we sent
4936 with the lock type set to POSIX_LOCK_TYPE_UNLOCK. */
4937 data_size
= POSIX_LOCK_DATA_SIZE
;
4938 memcpy(pdata
, lock_data
, POSIX_LOCK_DATA_SIZE
);
4939 SSVAL(pdata
, POSIX_LOCK_TYPE_OFFSET
, POSIX_LOCK_TYPE_UNLOCK
);
4947 return NT_STATUS_INVALID_LEVEL
;
4950 *pdata_size
= data_size
;
4951 return NT_STATUS_OK
;
4954 /****************************************************************************
4955 Reply to a TRANS2_QFILEPATHINFO or TRANSACT2_QFILEINFO (query file info by
4956 file name or file id).
4957 ****************************************************************************/
4959 static void call_trans2qfilepathinfo(connection_struct
*conn
,
4960 struct smb_request
*req
,
4961 unsigned int tran_call
,
4962 char **pparams
, int total_params
,
4963 char **ppdata
, int total_data
,
4964 unsigned int max_data_bytes
)
4966 char *params
= *pparams
;
4967 char *pdata
= *ppdata
;
4969 unsigned int data_size
= 0;
4970 unsigned int param_size
= 2;
4971 struct smb_filename
*smb_fname
= NULL
;
4972 bool delete_pending
= False
;
4973 struct timespec write_time_ts
;
4974 files_struct
*fsp
= NULL
;
4975 struct file_id fileid
;
4976 struct ea_list
*ea_list
= NULL
;
4977 int lock_data_count
= 0;
4978 char *lock_data
= NULL
;
4979 bool ms_dfs_link
= false;
4980 NTSTATUS status
= NT_STATUS_OK
;
4983 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
4987 ZERO_STRUCT(write_time_ts
);
4989 if (tran_call
== TRANSACT2_QFILEINFO
) {
4990 if (total_params
< 4) {
4991 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
4996 call_trans2qpipeinfo(conn
, req
, tran_call
,
4997 pparams
, total_params
,
5003 fsp
= file_fsp(req
, SVAL(params
,0));
5004 info_level
= SVAL(params
,2);
5006 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QFILEINFO: level = %d\n", info_level
));
5008 if (INFO_LEVEL_IS_UNIX(info_level
) && !lp_unix_extensions()) {
5009 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
5013 /* Initial check for valid fsp ptr. */
5014 if (!check_fsp_open(conn
, req
, fsp
)) {
5018 status
= copy_smb_filename(talloc_tos(), fsp
->fsp_name
,
5020 if (!NT_STATUS_IS_OK(status
)) {
5021 reply_nterror(req
, status
);
5025 if(fsp
->fake_file_handle
) {
5027 * This is actually for the QUOTA_FAKE_FILE --metze
5030 /* We know this name is ok, it's already passed the checks. */
5032 } else if(fsp
->is_directory
|| fsp
->fh
->fd
== -1) {
5034 * This is actually a QFILEINFO on a directory
5035 * handle (returned from an NT SMB). NT5.0 seems
5036 * to do this call. JRA.
5039 if (INFO_LEVEL_IS_UNIX(info_level
)) {
5040 /* Always do lstat for UNIX calls. */
5041 if (SMB_VFS_LSTAT(conn
, smb_fname
)) {
5042 DEBUG(3,("call_trans2qfilepathinfo: "
5043 "SMB_VFS_LSTAT of %s failed "
5045 smb_fname_str_dbg(smb_fname
),
5048 map_nt_error_from_unix(errno
));
5051 } else if (SMB_VFS_STAT(conn
, smb_fname
)) {
5052 DEBUG(3,("call_trans2qfilepathinfo: "
5053 "SMB_VFS_STAT of %s failed (%s)\n",
5054 smb_fname_str_dbg(smb_fname
),
5057 map_nt_error_from_unix(errno
));
5061 fileid
= vfs_file_id_from_sbuf(conn
, &smb_fname
->st
);
5062 get_file_infos(fileid
, &delete_pending
, &write_time_ts
);
5065 * Original code - this is an open file.
5067 if (!check_fsp(conn
, req
, fsp
)) {
5071 if (SMB_VFS_FSTAT(fsp
, &smb_fname
->st
) != 0) {
5072 DEBUG(3, ("fstat of fnum %d failed (%s)\n",
5073 fsp
->fnum
, strerror(errno
)));
5075 map_nt_error_from_unix(errno
));
5078 fileid
= vfs_file_id_from_sbuf(conn
, &smb_fname
->st
);
5079 get_file_infos(fileid
, &delete_pending
, &write_time_ts
);
5086 if (total_params
< 7) {
5087 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
5091 info_level
= SVAL(params
,0);
5093 DEBUG(3,("call_trans2qfilepathinfo: TRANSACT2_QPATHINFO: level = %d\n", info_level
));
5095 if (INFO_LEVEL_IS_UNIX(info_level
) && !lp_unix_extensions()) {
5096 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
5100 srvstr_get_path(req
, params
, req
->flags2
, &fname
, ¶ms
[6],
5102 STR_TERMINATE
, &status
);
5103 if (!NT_STATUS_IS_OK(status
)) {
5104 reply_nterror(req
, status
);
5108 status
= filename_convert(req
,
5110 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
5115 if (!NT_STATUS_IS_OK(status
)) {
5116 if (NT_STATUS_EQUAL(status
,NT_STATUS_PATH_NOT_COVERED
)) {
5117 reply_botherror(req
,
5118 NT_STATUS_PATH_NOT_COVERED
,
5119 ERRSRV
, ERRbadpath
);
5122 reply_nterror(req
, status
);
5126 /* If this is a stream, check if there is a delete_pending. */
5127 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
5128 && is_ntfs_stream_smb_fname(smb_fname
)) {
5129 struct smb_filename
*smb_fname_base
= NULL
;
5131 /* Create an smb_filename with stream_name == NULL. */
5133 create_synthetic_smb_fname(talloc_tos(),
5134 smb_fname
->base_name
,
5137 if (!NT_STATUS_IS_OK(status
)) {
5138 reply_nterror(req
, status
);
5142 if (INFO_LEVEL_IS_UNIX(info_level
)) {
5143 /* Always do lstat for UNIX calls. */
5144 if (SMB_VFS_LSTAT(conn
, smb_fname_base
) != 0) {
5145 DEBUG(3,("call_trans2qfilepathinfo: "
5146 "SMB_VFS_LSTAT of %s failed "
5148 smb_fname_str_dbg(smb_fname_base
),
5150 TALLOC_FREE(smb_fname_base
);
5152 map_nt_error_from_unix(errno
));
5156 if (SMB_VFS_STAT(conn
, smb_fname_base
) != 0) {
5157 DEBUG(3,("call_trans2qfilepathinfo: "
5158 "fileinfo of %s failed "
5160 smb_fname_str_dbg(smb_fname_base
),
5162 TALLOC_FREE(smb_fname_base
);
5164 map_nt_error_from_unix(errno
));
5169 fileid
= vfs_file_id_from_sbuf(conn
,
5170 &smb_fname_base
->st
);
5171 TALLOC_FREE(smb_fname_base
);
5172 get_file_infos(fileid
, &delete_pending
, NULL
);
5173 if (delete_pending
) {
5174 reply_nterror(req
, NT_STATUS_DELETE_PENDING
);
5179 if (INFO_LEVEL_IS_UNIX(info_level
)) {
5180 /* Always do lstat for UNIX calls. */
5181 if (SMB_VFS_LSTAT(conn
, smb_fname
)) {
5182 DEBUG(3,("call_trans2qfilepathinfo: "
5183 "SMB_VFS_LSTAT of %s failed (%s)\n",
5184 smb_fname_str_dbg(smb_fname
),
5187 map_nt_error_from_unix(errno
));
5191 } else if (!VALID_STAT(smb_fname
->st
) &&
5192 SMB_VFS_STAT(conn
, smb_fname
) &&
5193 (info_level
!= SMB_INFO_IS_NAME_VALID
)) {
5194 ms_dfs_link
= check_msdfs_link(conn
,
5195 smb_fname
->base_name
,
5199 DEBUG(3,("call_trans2qfilepathinfo: "
5200 "SMB_VFS_STAT of %s failed (%s)\n",
5201 smb_fname_str_dbg(smb_fname
),
5204 map_nt_error_from_unix(errno
));
5209 fileid
= vfs_file_id_from_sbuf(conn
, &smb_fname
->st
);
5210 get_file_infos(fileid
, &delete_pending
, &write_time_ts
);
5211 if (delete_pending
) {
5212 reply_nterror(req
, NT_STATUS_DELETE_PENDING
);
5217 DEBUG(3,("call_trans2qfilepathinfo %s (fnum = %d) level=%d call=%d "
5218 "total_data=%d\n", smb_fname_str_dbg(smb_fname
),
5219 fsp
? fsp
->fnum
: -1, info_level
,tran_call
,total_data
));
5221 /* Pull out any data sent here before we realloc. */
5222 switch (info_level
) {
5223 case SMB_INFO_QUERY_EAS_FROM_LIST
:
5225 /* Pull any EA list from the data portion. */
5228 if (total_data
< 4) {
5230 req
, NT_STATUS_INVALID_PARAMETER
);
5233 ea_size
= IVAL(pdata
,0);
5235 if (total_data
> 0 && ea_size
!= total_data
) {
5236 DEBUG(4,("call_trans2qfilepathinfo: Rejecting EA request with incorrect \
5237 total_data=%u (should be %u)\n", (unsigned int)total_data
, (unsigned int)IVAL(pdata
,0) ));
5239 req
, NT_STATUS_INVALID_PARAMETER
);
5243 if (!lp_ea_support(SNUM(conn
))) {
5244 reply_nterror(req
, NT_STATUS_EAS_NOT_SUPPORTED
);
5248 /* Pull out the list of names. */
5249 ea_list
= read_ea_name_list(req
, pdata
+ 4, ea_size
- 4);
5252 req
, NT_STATUS_INVALID_PARAMETER
);
5258 case SMB_QUERY_POSIX_LOCK
:
5260 if (fsp
== NULL
|| fsp
->fh
->fd
== -1) {
5261 reply_nterror(req
, NT_STATUS_INVALID_HANDLE
);
5265 if (total_data
!= POSIX_LOCK_DATA_SIZE
) {
5267 req
, NT_STATUS_INVALID_PARAMETER
);
5271 /* Copy the lock range data. */
5272 lock_data
= (char *)TALLOC_MEMDUP(
5273 req
, pdata
, total_data
);
5275 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
5278 lock_data_count
= total_data
;
5284 *pparams
= (char *)SMB_REALLOC(*pparams
,2);
5285 if (*pparams
== NULL
) {
5286 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
5293 * draft-leach-cifs-v1-spec-02.txt
5294 * 4.2.14 TRANS2_QUERY_PATH_INFORMATION: Get File Attributes given Path
5297 * The requested information is placed in the Data portion of the
5298 * transaction response. For the information levels greater than 0x100,
5299 * the transaction response has 1 parameter word which should be
5300 * ignored by the client.
5302 * However Windows only follows this rule for the IS_NAME_VALID call.
5304 switch (info_level
) {
5305 case SMB_INFO_IS_NAME_VALID
:
5310 if ((info_level
& 0xFF00) == 0xFF00) {
5312 * We use levels that start with 0xFF00
5313 * internally to represent SMB2 specific levels
5315 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
5319 status
= smbd_do_qfilepathinfo(conn
, req
, info_level
,
5321 delete_pending
, write_time_ts
,
5322 ms_dfs_link
, ea_list
,
5323 lock_data_count
, lock_data
,
5324 req
->flags2
, max_data_bytes
,
5325 ppdata
, &data_size
);
5326 if (!NT_STATUS_IS_OK(status
)) {
5327 reply_nterror(req
, status
);
5331 send_trans2_replies(conn
, req
, params
, param_size
, *ppdata
, data_size
,
5337 /****************************************************************************
5338 Set a hard link (called by UNIX extensions and by NT rename with HARD link
5340 ****************************************************************************/
5342 NTSTATUS
hardlink_internals(TALLOC_CTX
*ctx
,
5343 connection_struct
*conn
,
5344 const struct smb_filename
*smb_fname_old
,
5345 const struct smb_filename
*smb_fname_new
)
5347 NTSTATUS status
= NT_STATUS_OK
;
5349 /* source must already exist. */
5350 if (!VALID_STAT(smb_fname_old
->st
)) {
5351 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
5354 /* Disallow if newname already exists. */
5355 if (VALID_STAT(smb_fname_new
->st
)) {
5356 return NT_STATUS_OBJECT_NAME_COLLISION
;
5359 /* No links from a directory. */
5360 if (S_ISDIR(smb_fname_old
->st
.st_ex_mode
)) {
5361 return NT_STATUS_FILE_IS_A_DIRECTORY
;
5364 /* Setting a hardlink to/from a stream isn't currently supported. */
5365 if (is_ntfs_stream_smb_fname(smb_fname_old
) ||
5366 is_ntfs_stream_smb_fname(smb_fname_new
)) {
5367 return NT_STATUS_INVALID_PARAMETER
;
5370 DEBUG(10,("hardlink_internals: doing hard link %s -> %s\n",
5371 smb_fname_old
->base_name
, smb_fname_new
->base_name
));
5373 if (SMB_VFS_LINK(conn
, smb_fname_old
->base_name
,
5374 smb_fname_new
->base_name
) != 0) {
5375 status
= map_nt_error_from_unix(errno
);
5376 DEBUG(3,("hardlink_internals: Error %s hard link %s -> %s\n",
5377 nt_errstr(status
), smb_fname_old
->base_name
,
5378 smb_fname_new
->base_name
));
5383 /****************************************************************************
5384 Deal with setting the time from any of the setfilepathinfo functions.
5385 ****************************************************************************/
5387 NTSTATUS
smb_set_file_time(connection_struct
*conn
,
5389 const struct smb_filename
*smb_fname
,
5390 struct smb_file_time
*ft
,
5391 bool setting_write_time
)
5393 struct smb_filename smb_fname_base
;
5395 FILE_NOTIFY_CHANGE_LAST_ACCESS
5396 |FILE_NOTIFY_CHANGE_LAST_WRITE
5397 |FILE_NOTIFY_CHANGE_CREATION
;
5399 if (!VALID_STAT(smb_fname
->st
)) {
5400 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
5403 /* get some defaults (no modifications) if any info is zero or -1. */
5404 if (null_timespec(ft
->create_time
)) {
5405 action
&= ~FILE_NOTIFY_CHANGE_CREATION
;
5408 if (null_timespec(ft
->atime
)) {
5409 action
&= ~FILE_NOTIFY_CHANGE_LAST_ACCESS
;
5412 if (null_timespec(ft
->mtime
)) {
5413 action
&= ~FILE_NOTIFY_CHANGE_LAST_WRITE
;
5416 if (!setting_write_time
) {
5417 /* ft->mtime comes from change time, not write time. */
5418 action
&= ~FILE_NOTIFY_CHANGE_LAST_WRITE
;
5421 /* Ensure the resolution is the correct for
5422 * what we can store on this filesystem. */
5424 round_timespec(conn
->ts_res
, &ft
->create_time
);
5425 round_timespec(conn
->ts_res
, &ft
->ctime
);
5426 round_timespec(conn
->ts_res
, &ft
->atime
);
5427 round_timespec(conn
->ts_res
, &ft
->mtime
);
5429 DEBUG(5,("smb_set_filetime: actime: %s\n ",
5430 time_to_asc(convert_timespec_to_time_t(ft
->atime
))));
5431 DEBUG(5,("smb_set_filetime: modtime: %s\n ",
5432 time_to_asc(convert_timespec_to_time_t(ft
->mtime
))));
5433 DEBUG(5,("smb_set_filetime: ctime: %s\n ",
5434 time_to_asc(convert_timespec_to_time_t(ft
->ctime
))));
5435 DEBUG(5,("smb_set_file_time: createtime: %s\n ",
5436 time_to_asc(convert_timespec_to_time_t(ft
->create_time
))));
5438 if (setting_write_time
) {
5440 * This was a Windows setfileinfo on an open file.
5441 * NT does this a lot. We also need to
5442 * set the time here, as it can be read by
5443 * FindFirst/FindNext and with the patch for bug #2045
5444 * in smbd/fileio.c it ensures that this timestamp is
5445 * kept sticky even after a write. We save the request
5446 * away and will set it on file close and after a write. JRA.
5449 DEBUG(10,("smb_set_file_time: setting pending modtime to %s\n",
5450 time_to_asc(convert_timespec_to_time_t(ft
->mtime
))));
5453 if (fsp
->base_fsp
) {
5454 set_sticky_write_time_fsp(fsp
->base_fsp
,
5457 set_sticky_write_time_fsp(fsp
, ft
->mtime
);
5460 set_sticky_write_time_path(
5461 vfs_file_id_from_sbuf(conn
, &smb_fname
->st
),
5466 DEBUG(10,("smb_set_file_time: setting utimes to modified values.\n"));
5468 /* Always call ntimes on the base, even if a stream was passed in. */
5469 smb_fname_base
= *smb_fname
;
5470 smb_fname_base
.stream_name
= NULL
;
5472 if(file_ntimes(conn
, &smb_fname_base
, ft
)!=0) {
5473 return map_nt_error_from_unix(errno
);
5476 notify_fname(conn
, NOTIFY_ACTION_MODIFIED
, action
,
5477 smb_fname
->base_name
);
5478 return NT_STATUS_OK
;
5481 /****************************************************************************
5482 Deal with setting the dosmode from any of the setfilepathinfo functions.
5483 ****************************************************************************/
5485 static NTSTATUS
smb_set_file_dosmode(connection_struct
*conn
,
5486 const struct smb_filename
*smb_fname
,
5489 struct smb_filename
*smb_fname_base
= NULL
;
5492 if (!VALID_STAT(smb_fname
->st
)) {
5493 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
5496 /* Always operate on the base_name, even if a stream was passed in. */
5497 status
= create_synthetic_smb_fname(talloc_tos(), smb_fname
->base_name
,
5498 NULL
, &smb_fname
->st
,
5500 if (!NT_STATUS_IS_OK(status
)) {
5505 if (S_ISDIR(smb_fname_base
->st
.st_ex_mode
)) {
5512 DEBUG(6,("smb_set_file_dosmode: dosmode: 0x%x\n", (unsigned int)dosmode
));
5514 /* check the mode isn't different, before changing it */
5515 if ((dosmode
!= 0) && (dosmode
!= dos_mode(conn
, smb_fname_base
))) {
5516 DEBUG(10,("smb_set_file_dosmode: file %s : setting dos mode "
5517 "0x%x\n", smb_fname_str_dbg(smb_fname_base
),
5518 (unsigned int)dosmode
));
5520 if(file_set_dosmode(conn
, smb_fname_base
, dosmode
, NULL
,
5522 DEBUG(2,("smb_set_file_dosmode: file_set_dosmode of "
5524 smb_fname_str_dbg(smb_fname_base
),
5526 status
= map_nt_error_from_unix(errno
);
5530 status
= NT_STATUS_OK
;
5532 TALLOC_FREE(smb_fname_base
);
5536 /****************************************************************************
5537 Deal with setting the size from any of the setfilepathinfo functions.
5538 ****************************************************************************/
5540 static NTSTATUS
smb_set_file_size(connection_struct
*conn
,
5541 struct smb_request
*req
,
5543 const struct smb_filename
*smb_fname
,
5544 const SMB_STRUCT_STAT
*psbuf
,
5546 bool fail_after_createfile
)
5548 NTSTATUS status
= NT_STATUS_OK
;
5549 struct smb_filename
*smb_fname_tmp
= NULL
;
5550 files_struct
*new_fsp
= NULL
;
5552 if (!VALID_STAT(*psbuf
)) {
5553 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
5556 DEBUG(6,("smb_set_file_size: size: %.0f ", (double)size
));
5558 if (size
== get_file_size_stat(psbuf
)) {
5559 return NT_STATUS_OK
;
5562 DEBUG(10,("smb_set_file_size: file %s : setting new size to %.0f\n",
5563 smb_fname_str_dbg(smb_fname
), (double)size
));
5565 if (fsp
&& fsp
->fh
->fd
!= -1) {
5566 /* Handle based call. */
5567 if (vfs_set_filelen(fsp
, size
) == -1) {
5568 return map_nt_error_from_unix(errno
);
5570 trigger_write_time_update_immediate(fsp
);
5571 return NT_STATUS_OK
;
5574 status
= copy_smb_filename(talloc_tos(), smb_fname
, &smb_fname_tmp
);
5575 if (!NT_STATUS_IS_OK(status
)) {
5579 smb_fname_tmp
->st
= *psbuf
;
5581 status
= SMB_VFS_CREATE_FILE(
5584 0, /* root_dir_fid */
5585 smb_fname_tmp
, /* fname */
5586 FILE_WRITE_DATA
, /* access_mask */
5587 (FILE_SHARE_READ
| FILE_SHARE_WRITE
| /* share_access */
5589 FILE_OPEN
, /* create_disposition*/
5590 0, /* create_options */
5591 FILE_ATTRIBUTE_NORMAL
, /* file_attributes */
5592 FORCE_OPLOCK_BREAK_TO_NONE
, /* oplock_request */
5593 0, /* allocation_size */
5594 0, /* private_flags */
5597 &new_fsp
, /* result */
5600 TALLOC_FREE(smb_fname_tmp
);
5602 if (!NT_STATUS_IS_OK(status
)) {
5603 /* NB. We check for open_was_deferred in the caller. */
5607 /* See RAW-SFILEINFO-END-OF-FILE */
5608 if (fail_after_createfile
) {
5609 close_file(req
, new_fsp
,NORMAL_CLOSE
);
5610 return NT_STATUS_INVALID_LEVEL
;
5613 if (vfs_set_filelen(new_fsp
, size
) == -1) {
5614 status
= map_nt_error_from_unix(errno
);
5615 close_file(req
, new_fsp
,NORMAL_CLOSE
);
5619 trigger_write_time_update_immediate(new_fsp
);
5620 close_file(req
, new_fsp
,NORMAL_CLOSE
);
5621 return NT_STATUS_OK
;
5624 /****************************************************************************
5625 Deal with SMB_INFO_SET_EA.
5626 ****************************************************************************/
5628 static NTSTATUS
smb_info_set_ea(connection_struct
*conn
,
5632 const struct smb_filename
*smb_fname
)
5634 struct ea_list
*ea_list
= NULL
;
5635 TALLOC_CTX
*ctx
= NULL
;
5636 NTSTATUS status
= NT_STATUS_OK
;
5638 if (total_data
< 10) {
5640 /* OS/2 workplace shell seems to send SET_EA requests of "null"
5641 length. They seem to have no effect. Bug #3212. JRA */
5643 if ((total_data
== 4) && (IVAL(pdata
,0) == 4)) {
5644 /* We're done. We only get EA info in this call. */
5645 return NT_STATUS_OK
;
5648 return NT_STATUS_INVALID_PARAMETER
;
5651 if (IVAL(pdata
,0) > total_data
) {
5652 DEBUG(10,("smb_info_set_ea: bad total data size (%u) > %u\n",
5653 IVAL(pdata
,0), (unsigned int)total_data
));
5654 return NT_STATUS_INVALID_PARAMETER
;
5658 ea_list
= read_ea_list(ctx
, pdata
+ 4, total_data
- 4);
5660 return NT_STATUS_INVALID_PARAMETER
;
5662 status
= set_ea(conn
, fsp
, smb_fname
, ea_list
);
5667 /****************************************************************************
5668 Deal with SMB_FILE_FULL_EA_INFORMATION set.
5669 ****************************************************************************/
5671 static NTSTATUS
smb_set_file_full_ea_info(connection_struct
*conn
,
5676 struct ea_list
*ea_list
= NULL
;
5680 return NT_STATUS_INVALID_HANDLE
;
5683 if (!lp_ea_support(SNUM(conn
))) {
5684 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u but "
5685 "EA's not supported.\n",
5686 (unsigned int)total_data
));
5687 return NT_STATUS_EAS_NOT_SUPPORTED
;
5690 if (total_data
< 10) {
5691 DEBUG(10, ("smb_set_file_full_ea_info - ea_len = %u "
5693 (unsigned int)total_data
));
5694 return NT_STATUS_INVALID_PARAMETER
;
5697 ea_list
= read_nttrans_ea_list(talloc_tos(),
5702 return NT_STATUS_INVALID_PARAMETER
;
5704 status
= set_ea(conn
, fsp
, fsp
->fsp_name
, ea_list
);
5706 DEBUG(10, ("smb_set_file_full_ea_info on file %s returned %s\n",
5707 smb_fname_str_dbg(fsp
->fsp_name
),
5708 nt_errstr(status
) ));
5714 /****************************************************************************
5715 Deal with SMB_SET_FILE_DISPOSITION_INFO.
5716 ****************************************************************************/
5718 static NTSTATUS
smb_set_file_disposition_info(connection_struct
*conn
,
5722 struct smb_filename
*smb_fname
)
5724 NTSTATUS status
= NT_STATUS_OK
;
5725 bool delete_on_close
;
5728 if (total_data
< 1) {
5729 return NT_STATUS_INVALID_PARAMETER
;
5733 return NT_STATUS_INVALID_HANDLE
;
5736 delete_on_close
= (CVAL(pdata
,0) ? True
: False
);
5737 dosmode
= dos_mode(conn
, smb_fname
);
5739 DEBUG(10,("smb_set_file_disposition_info: file %s, dosmode = %u, "
5740 "delete_on_close = %u\n",
5741 smb_fname_str_dbg(smb_fname
),
5742 (unsigned int)dosmode
,
5743 (unsigned int)delete_on_close
));
5745 if (delete_on_close
) {
5746 status
= can_set_delete_on_close(fsp
, dosmode
);
5747 if (!NT_STATUS_IS_OK(status
)) {
5752 /* The set is across all open files on this dev/inode pair. */
5753 if (!set_delete_on_close(fsp
, delete_on_close
,
5754 &conn
->server_info
->utok
)) {
5755 return NT_STATUS_ACCESS_DENIED
;
5757 return NT_STATUS_OK
;
5760 /****************************************************************************
5761 Deal with SMB_FILE_POSITION_INFORMATION.
5762 ****************************************************************************/
5764 static NTSTATUS
smb_file_position_information(connection_struct
*conn
,
5769 uint64_t position_information
;
5771 if (total_data
< 8) {
5772 return NT_STATUS_INVALID_PARAMETER
;
5776 /* Ignore on pathname based set. */
5777 return NT_STATUS_OK
;
5780 position_information
= (uint64_t)IVAL(pdata
,0);
5781 #ifdef LARGE_SMB_OFF_T
5782 position_information
|= (((uint64_t)IVAL(pdata
,4)) << 32);
5783 #else /* LARGE_SMB_OFF_T */
5784 if (IVAL(pdata
,4) != 0) {
5785 /* more than 32 bits? */
5786 return NT_STATUS_INVALID_PARAMETER
;
5788 #endif /* LARGE_SMB_OFF_T */
5790 DEBUG(10,("smb_file_position_information: Set file position "
5791 "information for file %s to %.0f\n", fsp_str_dbg(fsp
),
5792 (double)position_information
));
5793 fsp
->fh
->position_information
= position_information
;
5794 return NT_STATUS_OK
;
5797 /****************************************************************************
5798 Deal with SMB_FILE_MODE_INFORMATION.
5799 ****************************************************************************/
5801 static NTSTATUS
smb_file_mode_information(connection_struct
*conn
,
5807 if (total_data
< 4) {
5808 return NT_STATUS_INVALID_PARAMETER
;
5810 mode
= IVAL(pdata
,0);
5811 if (mode
!= 0 && mode
!= 2 && mode
!= 4 && mode
!= 6) {
5812 return NT_STATUS_INVALID_PARAMETER
;
5814 return NT_STATUS_OK
;
5817 /****************************************************************************
5818 Deal with SMB_SET_FILE_UNIX_LINK (create a UNIX symlink).
5819 ****************************************************************************/
5821 static NTSTATUS
smb_set_file_unix_link(connection_struct
*conn
,
5822 struct smb_request
*req
,
5825 const struct smb_filename
*smb_fname
)
5827 char *link_target
= NULL
;
5828 const char *newname
= smb_fname
->base_name
;
5829 TALLOC_CTX
*ctx
= talloc_tos();
5831 /* Set a symbolic link. */
5832 /* Don't allow this if follow links is false. */
5834 if (total_data
== 0) {
5835 return NT_STATUS_INVALID_PARAMETER
;
5838 if (!lp_symlinks(SNUM(conn
))) {
5839 return NT_STATUS_ACCESS_DENIED
;
5842 srvstr_pull_talloc(ctx
, pdata
, req
->flags2
, &link_target
, pdata
,
5843 total_data
, STR_TERMINATE
);
5846 return NT_STATUS_INVALID_PARAMETER
;
5849 DEBUG(10,("smb_set_file_unix_link: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
5850 newname
, link_target
));
5852 if (SMB_VFS_SYMLINK(conn
,link_target
,newname
) != 0) {
5853 return map_nt_error_from_unix(errno
);
5856 return NT_STATUS_OK
;
5859 /****************************************************************************
5860 Deal with SMB_SET_FILE_UNIX_HLINK (create a UNIX hard link).
5861 ****************************************************************************/
5863 static NTSTATUS
smb_set_file_unix_hlink(connection_struct
*conn
,
5864 struct smb_request
*req
,
5865 const char *pdata
, int total_data
,
5866 const struct smb_filename
*smb_fname_new
)
5868 char *oldname
= NULL
;
5869 struct smb_filename
*smb_fname_old
= NULL
;
5870 TALLOC_CTX
*ctx
= talloc_tos();
5871 NTSTATUS status
= NT_STATUS_OK
;
5873 /* Set a hard link. */
5874 if (total_data
== 0) {
5875 return NT_STATUS_INVALID_PARAMETER
;
5878 srvstr_get_path(ctx
, pdata
, req
->flags2
, &oldname
, pdata
,
5879 total_data
, STR_TERMINATE
, &status
);
5880 if (!NT_STATUS_IS_OK(status
)) {
5884 DEBUG(10,("smb_set_file_unix_hlink: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
5885 smb_fname_str_dbg(smb_fname_new
), oldname
));
5887 status
= filename_convert(ctx
,
5889 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
5894 if (!NT_STATUS_IS_OK(status
)) {
5898 return hardlink_internals(ctx
, conn
, smb_fname_old
, smb_fname_new
);
5901 /****************************************************************************
5902 Deal with SMB2_FILE_RENAME_INFORMATION_INTERNAL
5903 ****************************************************************************/
5905 static NTSTATUS
smb2_file_rename_information(connection_struct
*conn
,
5906 struct smb_request
*req
,
5910 struct smb_filename
*smb_fname_src
)
5914 char *newname
= NULL
;
5915 struct smb_filename
*smb_fname_dst
= NULL
;
5916 NTSTATUS status
= NT_STATUS_OK
;
5917 TALLOC_CTX
*ctx
= talloc_tos();
5920 return NT_STATUS_INVALID_HANDLE
;
5923 if (total_data
< 20) {
5924 return NT_STATUS_INVALID_PARAMETER
;
5927 overwrite
= (CVAL(pdata
,0) ? True
: False
);
5928 len
= IVAL(pdata
,16);
5930 if (len
> (total_data
- 20) || (len
== 0)) {
5931 return NT_STATUS_INVALID_PARAMETER
;
5934 srvstr_get_path(ctx
, pdata
, req
->flags2
, &newname
,
5935 &pdata
[20], len
, STR_TERMINATE
,
5937 if (!NT_STATUS_IS_OK(status
)) {
5941 DEBUG(10,("smb2_file_rename_information: got name |%s|\n",
5944 status
= filename_convert(ctx
,
5946 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
5951 if (!NT_STATUS_IS_OK(status
)) {
5955 if (fsp
&& fsp
->base_fsp
) {
5956 /* newname must be a stream name. */
5957 if (newname
[0] != ':') {
5958 return NT_STATUS_NOT_SUPPORTED
;
5961 /* Create an smb_fname to call rename_internals_fsp() with. */
5962 status
= create_synthetic_smb_fname(talloc_tos(),
5963 fsp
->base_fsp
->fsp_name
->base_name
, newname
, NULL
,
5965 if (!NT_STATUS_IS_OK(status
)) {
5970 * Set the original last component, since
5971 * rename_internals_fsp() requires it.
5973 smb_fname_dst
->original_lcomp
= talloc_strdup(smb_fname_dst
,
5975 if (smb_fname_dst
->original_lcomp
== NULL
) {
5976 status
= NT_STATUS_NO_MEMORY
;
5982 DEBUG(10,("smb2_file_rename_information: "
5983 "SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
5984 fsp
->fnum
, fsp_str_dbg(fsp
),
5985 smb_fname_str_dbg(smb_fname_dst
)));
5986 status
= rename_internals_fsp(conn
, fsp
, smb_fname_dst
, 0,
5990 TALLOC_FREE(smb_fname_dst
);
5995 /****************************************************************************
5996 Deal with SMB_FILE_RENAME_INFORMATION.
5997 ****************************************************************************/
5999 static NTSTATUS
smb_file_rename_information(connection_struct
*conn
,
6000 struct smb_request
*req
,
6004 struct smb_filename
*smb_fname_src
)
6009 char *newname
= NULL
;
6010 struct smb_filename
*smb_fname_dst
= NULL
;
6011 bool dest_has_wcard
= False
;
6012 NTSTATUS status
= NT_STATUS_OK
;
6014 TALLOC_CTX
*ctx
= talloc_tos();
6016 if (total_data
< 13) {
6017 return NT_STATUS_INVALID_PARAMETER
;
6020 overwrite
= (CVAL(pdata
,0) ? True
: False
);
6021 root_fid
= IVAL(pdata
,4);
6022 len
= IVAL(pdata
,8);
6024 if (len
> (total_data
- 12) || (len
== 0) || (root_fid
!= 0)) {
6025 return NT_STATUS_INVALID_PARAMETER
;
6028 srvstr_get_path_wcard(ctx
, pdata
, req
->flags2
, &newname
, &pdata
[12],
6031 if (!NT_STATUS_IS_OK(status
)) {
6035 DEBUG(10,("smb_file_rename_information: got name |%s|\n",
6038 status
= resolve_dfspath_wcard(ctx
, conn
,
6039 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
6043 if (!NT_STATUS_IS_OK(status
)) {
6047 /* Check the new name has no '/' characters. */
6048 if (strchr_m(newname
, '/')) {
6049 return NT_STATUS_NOT_SUPPORTED
;
6052 if (fsp
&& fsp
->base_fsp
) {
6053 /* newname must be a stream name. */
6054 if (newname
[0] != ':') {
6055 return NT_STATUS_NOT_SUPPORTED
;
6058 /* Create an smb_fname to call rename_internals_fsp() with. */
6059 status
= create_synthetic_smb_fname(talloc_tos(),
6060 fsp
->base_fsp
->fsp_name
->base_name
, newname
, NULL
,
6062 if (!NT_STATUS_IS_OK(status
)) {
6067 * Set the original last component, since
6068 * rename_internals_fsp() requires it.
6070 smb_fname_dst
->original_lcomp
= talloc_strdup(smb_fname_dst
,
6072 if (smb_fname_dst
->original_lcomp
== NULL
) {
6073 status
= NT_STATUS_NO_MEMORY
;
6079 * Build up an smb_fname_dst based on the filename passed in.
6080 * We basically just strip off the last component, and put on
6081 * the newname instead.
6083 char *base_name
= NULL
;
6085 /* newname must *not* be a stream name. */
6086 if (newname
[0] == ':') {
6087 return NT_STATUS_NOT_SUPPORTED
;
6091 * Strip off the last component (filename) of the path passed
6094 base_name
= talloc_strdup(ctx
, smb_fname_src
->base_name
);
6096 return NT_STATUS_NO_MEMORY
;
6098 p
= strrchr_m(base_name
, '/');
6102 base_name
= talloc_strdup(ctx
, "./");
6104 return NT_STATUS_NO_MEMORY
;
6107 /* Append the new name. */
6108 base_name
= talloc_asprintf_append(base_name
,
6112 return NT_STATUS_NO_MEMORY
;
6115 status
= unix_convert(ctx
, conn
, base_name
, &smb_fname_dst
,
6118 UCF_ALWAYS_ALLOW_WCARD_LCOMP
:
6121 /* If an error we expect this to be
6122 * NT_STATUS_OBJECT_PATH_NOT_FOUND */
6124 if (!NT_STATUS_IS_OK(status
)) {
6125 if(!NT_STATUS_EQUAL(NT_STATUS_OBJECT_PATH_NOT_FOUND
,
6129 /* Create an smb_fname to call rename_internals_fsp() */
6130 status
= create_synthetic_smb_fname(ctx
,
6134 if (!NT_STATUS_IS_OK(status
)) {
6141 DEBUG(10,("smb_file_rename_information: "
6142 "SMB_FILE_RENAME_INFORMATION (fnum %d) %s -> %s\n",
6143 fsp
->fnum
, fsp_str_dbg(fsp
),
6144 smb_fname_str_dbg(smb_fname_dst
)));
6145 status
= rename_internals_fsp(conn
, fsp
, smb_fname_dst
, 0,
6148 DEBUG(10,("smb_file_rename_information: "
6149 "SMB_FILE_RENAME_INFORMATION %s -> %s\n",
6150 smb_fname_str_dbg(smb_fname_src
),
6151 smb_fname_str_dbg(smb_fname_dst
)));
6152 status
= rename_internals(ctx
, conn
, req
, smb_fname_src
,
6153 smb_fname_dst
, 0, overwrite
, false,
6155 FILE_WRITE_ATTRIBUTES
);
6158 TALLOC_FREE(smb_fname_dst
);
6162 /****************************************************************************
6163 Deal with SMB_SET_POSIX_ACL.
6164 ****************************************************************************/
6166 #if defined(HAVE_POSIX_ACLS)
6167 static NTSTATUS
smb_set_posix_acl(connection_struct
*conn
,
6171 const struct smb_filename
*smb_fname
)
6173 uint16 posix_acl_version
;
6174 uint16 num_file_acls
;
6175 uint16 num_def_acls
;
6176 bool valid_file_acls
= True
;
6177 bool valid_def_acls
= True
;
6179 if (total_data
< SMB_POSIX_ACL_HEADER_SIZE
) {
6180 return NT_STATUS_INVALID_PARAMETER
;
6182 posix_acl_version
= SVAL(pdata
,0);
6183 num_file_acls
= SVAL(pdata
,2);
6184 num_def_acls
= SVAL(pdata
,4);
6186 if (num_file_acls
== SMB_POSIX_IGNORE_ACE_ENTRIES
) {
6187 valid_file_acls
= False
;
6191 if (num_def_acls
== SMB_POSIX_IGNORE_ACE_ENTRIES
) {
6192 valid_def_acls
= False
;
6196 if (posix_acl_version
!= SMB_POSIX_ACL_VERSION
) {
6197 return NT_STATUS_INVALID_PARAMETER
;
6200 if (total_data
< SMB_POSIX_ACL_HEADER_SIZE
+
6201 (num_file_acls
+num_def_acls
)*SMB_POSIX_ACL_ENTRY_SIZE
) {
6202 return NT_STATUS_INVALID_PARAMETER
;
6205 DEBUG(10,("smb_set_posix_acl: file %s num_file_acls = %u, num_def_acls = %u\n",
6206 smb_fname
? smb_fname_str_dbg(smb_fname
) : fsp_str_dbg(fsp
),
6207 (unsigned int)num_file_acls
,
6208 (unsigned int)num_def_acls
));
6210 if (valid_file_acls
&& !set_unix_posix_acl(conn
, fsp
,
6211 smb_fname
->base_name
, num_file_acls
,
6212 pdata
+ SMB_POSIX_ACL_HEADER_SIZE
)) {
6213 return map_nt_error_from_unix(errno
);
6216 if (valid_def_acls
&& !set_unix_posix_default_acl(conn
,
6217 smb_fname
->base_name
, &smb_fname
->st
, num_def_acls
,
6218 pdata
+ SMB_POSIX_ACL_HEADER_SIZE
+
6219 (num_file_acls
*SMB_POSIX_ACL_ENTRY_SIZE
))) {
6220 return map_nt_error_from_unix(errno
);
6222 return NT_STATUS_OK
;
6226 /****************************************************************************
6227 Deal with SMB_SET_POSIX_LOCK.
6228 ****************************************************************************/
6230 static NTSTATUS
smb_set_posix_lock(connection_struct
*conn
,
6231 struct smb_request
*req
,
6239 bool blocking_lock
= False
;
6240 enum brl_type lock_type
;
6242 NTSTATUS status
= NT_STATUS_OK
;
6244 if (fsp
== NULL
|| fsp
->fh
->fd
== -1) {
6245 return NT_STATUS_INVALID_HANDLE
;
6248 if (total_data
!= POSIX_LOCK_DATA_SIZE
) {
6249 return NT_STATUS_INVALID_PARAMETER
;
6252 switch (SVAL(pdata
, POSIX_LOCK_TYPE_OFFSET
)) {
6253 case POSIX_LOCK_TYPE_READ
:
6254 lock_type
= READ_LOCK
;
6256 case POSIX_LOCK_TYPE_WRITE
:
6257 /* Return the right POSIX-mappable error code for files opened read-only. */
6258 if (!fsp
->can_write
) {
6259 return NT_STATUS_INVALID_HANDLE
;
6261 lock_type
= WRITE_LOCK
;
6263 case POSIX_LOCK_TYPE_UNLOCK
:
6264 lock_type
= UNLOCK_LOCK
;
6267 return NT_STATUS_INVALID_PARAMETER
;
6270 if (SVAL(pdata
,POSIX_LOCK_FLAGS_OFFSET
) == POSIX_LOCK_FLAG_NOWAIT
) {
6271 blocking_lock
= False
;
6272 } else if (SVAL(pdata
,POSIX_LOCK_FLAGS_OFFSET
) == POSIX_LOCK_FLAG_WAIT
) {
6273 blocking_lock
= True
;
6275 return NT_STATUS_INVALID_PARAMETER
;
6278 if (!lp_blocking_locks(SNUM(conn
))) {
6279 blocking_lock
= False
;
6282 lock_pid
= IVAL(pdata
, POSIX_LOCK_PID_OFFSET
);
6283 #if defined(HAVE_LONGLONG)
6284 offset
= (((uint64_t) IVAL(pdata
,(POSIX_LOCK_START_OFFSET
+4))) << 32) |
6285 ((uint64_t) IVAL(pdata
,POSIX_LOCK_START_OFFSET
));
6286 count
= (((uint64_t) IVAL(pdata
,(POSIX_LOCK_LEN_OFFSET
+4))) << 32) |
6287 ((uint64_t) IVAL(pdata
,POSIX_LOCK_LEN_OFFSET
));
6288 #else /* HAVE_LONGLONG */
6289 offset
= (uint64_t)IVAL(pdata
,POSIX_LOCK_START_OFFSET
);
6290 count
= (uint64_t)IVAL(pdata
,POSIX_LOCK_LEN_OFFSET
);
6291 #endif /* HAVE_LONGLONG */
6293 DEBUG(10,("smb_set_posix_lock: file %s, lock_type = %u,"
6294 "lock_pid = %u, count = %.0f, offset = %.0f\n",
6296 (unsigned int)lock_type
,
6297 (unsigned int)lock_pid
,
6301 if (lock_type
== UNLOCK_LOCK
) {
6302 status
= do_unlock(smbd_messaging_context(),
6309 uint32 block_smbpid
;
6311 struct byte_range_lock
*br_lck
= do_lock(smbd_messaging_context(),
6323 if (br_lck
&& blocking_lock
&& ERROR_WAS_LOCK_DENIED(status
)) {
6325 * A blocking lock was requested. Package up
6326 * this smb into a queued request and push it
6327 * onto the blocking lock queue.
6329 if(push_blocking_lock_request(br_lck
,
6332 -1, /* infinite timeout. */
6340 TALLOC_FREE(br_lck
);
6344 TALLOC_FREE(br_lck
);
6350 /****************************************************************************
6351 Deal with SMB_SET_FILE_BASIC_INFO.
6352 ****************************************************************************/
6354 static NTSTATUS
smb_set_file_basic_info(connection_struct
*conn
,
6358 const struct smb_filename
*smb_fname
)
6360 /* Patch to do this correctly from Paul Eggert <eggert@twinsun.com>. */
6361 struct smb_file_time ft
;
6363 NTSTATUS status
= NT_STATUS_OK
;
6367 if (total_data
< 36) {
6368 return NT_STATUS_INVALID_PARAMETER
;
6371 /* Set the attributes */
6372 dosmode
= IVAL(pdata
,32);
6373 status
= smb_set_file_dosmode(conn
, smb_fname
, dosmode
);
6374 if (!NT_STATUS_IS_OK(status
)) {
6379 ft
.create_time
= interpret_long_date(pdata
);
6382 ft
.atime
= interpret_long_date(pdata
+8);
6385 ft
.mtime
= interpret_long_date(pdata
+16);
6388 ft
.ctime
= interpret_long_date(pdata
+24);
6390 DEBUG(10, ("smb_set_file_basic_info: file %s\n",
6391 smb_fname_str_dbg(smb_fname
)));
6393 return smb_set_file_time(conn
, fsp
, smb_fname
, &ft
,
6397 /****************************************************************************
6398 Deal with SMB_INFO_STANDARD.
6399 ****************************************************************************/
6401 static NTSTATUS
smb_set_info_standard(connection_struct
*conn
,
6405 const struct smb_filename
*smb_fname
)
6407 struct smb_file_time ft
;
6411 if (total_data
< 12) {
6412 return NT_STATUS_INVALID_PARAMETER
;
6416 ft
.create_time
= convert_time_t_to_timespec(srv_make_unix_date2(pdata
));
6418 ft
.atime
= convert_time_t_to_timespec(srv_make_unix_date2(pdata
+4));
6420 ft
.mtime
= convert_time_t_to_timespec(srv_make_unix_date2(pdata
+8));
6422 DEBUG(10,("smb_set_info_standard: file %s\n",
6423 smb_fname_str_dbg(smb_fname
)));
6425 return smb_set_file_time(conn
,
6432 /****************************************************************************
6433 Deal with SMB_SET_FILE_ALLOCATION_INFO.
6434 ****************************************************************************/
6436 static NTSTATUS
smb_set_file_allocation_info(connection_struct
*conn
,
6437 struct smb_request
*req
,
6441 struct smb_filename
*smb_fname
)
6443 uint64_t allocation_size
= 0;
6444 NTSTATUS status
= NT_STATUS_OK
;
6445 files_struct
*new_fsp
= NULL
;
6447 if (!VALID_STAT(smb_fname
->st
)) {
6448 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
6451 if (total_data
< 8) {
6452 return NT_STATUS_INVALID_PARAMETER
;
6455 allocation_size
= (uint64_t)IVAL(pdata
,0);
6456 #ifdef LARGE_SMB_OFF_T
6457 allocation_size
|= (((uint64_t)IVAL(pdata
,4)) << 32);
6458 #else /* LARGE_SMB_OFF_T */
6459 if (IVAL(pdata
,4) != 0) {
6460 /* more than 32 bits? */
6461 return NT_STATUS_INVALID_PARAMETER
;
6463 #endif /* LARGE_SMB_OFF_T */
6465 DEBUG(10,("smb_set_file_allocation_info: Set file allocation info for "
6466 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname
),
6467 (double)allocation_size
));
6469 if (allocation_size
) {
6470 allocation_size
= smb_roundup(conn
, allocation_size
);
6473 DEBUG(10,("smb_set_file_allocation_info: file %s : setting new "
6474 "allocation size to %.0f\n", smb_fname_str_dbg(smb_fname
),
6475 (double)allocation_size
));
6477 if (fsp
&& fsp
->fh
->fd
!= -1) {
6478 /* Open file handle. */
6479 /* Only change if needed. */
6480 if (allocation_size
!= get_file_size_stat(&smb_fname
->st
)) {
6481 if (vfs_allocate_file_space(fsp
, allocation_size
) == -1) {
6482 return map_nt_error_from_unix(errno
);
6485 /* But always update the time. */
6487 * This is equivalent to a write. Ensure it's seen immediately
6488 * if there are no pending writes.
6490 trigger_write_time_update_immediate(fsp
);
6491 return NT_STATUS_OK
;
6494 /* Pathname or stat or directory file. */
6495 status
= SMB_VFS_CREATE_FILE(
6498 0, /* root_dir_fid */
6499 smb_fname
, /* fname */
6500 FILE_WRITE_DATA
, /* access_mask */
6501 (FILE_SHARE_READ
| FILE_SHARE_WRITE
| /* share_access */
6503 FILE_OPEN
, /* create_disposition*/
6504 0, /* create_options */
6505 FILE_ATTRIBUTE_NORMAL
, /* file_attributes */
6506 FORCE_OPLOCK_BREAK_TO_NONE
, /* oplock_request */
6507 0, /* allocation_size */
6508 0, /* private_flags */
6511 &new_fsp
, /* result */
6514 if (!NT_STATUS_IS_OK(status
)) {
6515 /* NB. We check for open_was_deferred in the caller. */
6519 /* Only change if needed. */
6520 if (allocation_size
!= get_file_size_stat(&smb_fname
->st
)) {
6521 if (vfs_allocate_file_space(new_fsp
, allocation_size
) == -1) {
6522 status
= map_nt_error_from_unix(errno
);
6523 close_file(req
, new_fsp
, NORMAL_CLOSE
);
6528 /* Changing the allocation size should set the last mod time. */
6530 * This is equivalent to a write. Ensure it's seen immediately
6531 * if there are no pending writes.
6533 trigger_write_time_update_immediate(new_fsp
);
6535 close_file(req
, new_fsp
, NORMAL_CLOSE
);
6536 return NT_STATUS_OK
;
6539 /****************************************************************************
6540 Deal with SMB_SET_FILE_END_OF_FILE_INFO.
6541 ****************************************************************************/
6543 static NTSTATUS
smb_set_file_end_of_file_info(connection_struct
*conn
,
6544 struct smb_request
*req
,
6548 const struct smb_filename
*smb_fname
,
6549 bool fail_after_createfile
)
6553 if (total_data
< 8) {
6554 return NT_STATUS_INVALID_PARAMETER
;
6557 size
= IVAL(pdata
,0);
6558 #ifdef LARGE_SMB_OFF_T
6559 size
|= (((SMB_OFF_T
)IVAL(pdata
,4)) << 32);
6560 #else /* LARGE_SMB_OFF_T */
6561 if (IVAL(pdata
,4) != 0) {
6562 /* more than 32 bits? */
6563 return NT_STATUS_INVALID_PARAMETER
;
6565 #endif /* LARGE_SMB_OFF_T */
6566 DEBUG(10,("smb_set_file_end_of_file_info: Set end of file info for "
6567 "file %s to %.0f\n", smb_fname_str_dbg(smb_fname
),
6570 return smb_set_file_size(conn
, req
,
6575 fail_after_createfile
);
6578 /****************************************************************************
6579 Allow a UNIX info mknod.
6580 ****************************************************************************/
6582 static NTSTATUS
smb_unix_mknod(connection_struct
*conn
,
6585 const struct smb_filename
*smb_fname
)
6587 uint32 file_type
= IVAL(pdata
,56);
6588 #if defined(HAVE_MAKEDEV)
6589 uint32 dev_major
= IVAL(pdata
,60);
6590 uint32 dev_minor
= IVAL(pdata
,68);
6592 SMB_DEV_T dev
= (SMB_DEV_T
)0;
6593 uint32 raw_unixmode
= IVAL(pdata
,84);
6597 if (total_data
< 100) {
6598 return NT_STATUS_INVALID_PARAMETER
;
6601 status
= unix_perms_from_wire(conn
, &smb_fname
->st
, raw_unixmode
,
6602 PERM_NEW_FILE
, &unixmode
);
6603 if (!NT_STATUS_IS_OK(status
)) {
6607 #if defined(HAVE_MAKEDEV)
6608 dev
= makedev(dev_major
, dev_minor
);
6611 switch (file_type
) {
6612 #if defined(S_IFIFO)
6613 case UNIX_TYPE_FIFO
:
6614 unixmode
|= S_IFIFO
;
6617 #if defined(S_IFSOCK)
6618 case UNIX_TYPE_SOCKET
:
6619 unixmode
|= S_IFSOCK
;
6622 #if defined(S_IFCHR)
6623 case UNIX_TYPE_CHARDEV
:
6624 unixmode
|= S_IFCHR
;
6627 #if defined(S_IFBLK)
6628 case UNIX_TYPE_BLKDEV
:
6629 unixmode
|= S_IFBLK
;
6633 return NT_STATUS_INVALID_PARAMETER
;
6636 DEBUG(10,("smb_unix_mknod: SMB_SET_FILE_UNIX_BASIC doing mknod dev "
6637 "%.0f mode 0%o for file %s\n", (double)dev
,
6638 (unsigned int)unixmode
, smb_fname_str_dbg(smb_fname
)));
6640 /* Ok - do the mknod. */
6641 if (SMB_VFS_MKNOD(conn
, smb_fname
->base_name
, unixmode
, dev
) != 0) {
6642 return map_nt_error_from_unix(errno
);
6645 /* If any of the other "set" calls fail we
6646 * don't want to end up with a half-constructed mknod.
6649 if (lp_inherit_perms(SNUM(conn
))) {
6651 if (!parent_dirname(talloc_tos(), smb_fname
->base_name
,
6653 return NT_STATUS_NO_MEMORY
;
6655 inherit_access_posix_acl(conn
, parent
, smb_fname
->base_name
,
6657 TALLOC_FREE(parent
);
6660 return NT_STATUS_OK
;
6663 /****************************************************************************
6664 Deal with SMB_SET_FILE_UNIX_BASIC.
6665 ****************************************************************************/
6667 static NTSTATUS
smb_set_file_unix_basic(connection_struct
*conn
,
6668 struct smb_request
*req
,
6672 const struct smb_filename
*smb_fname
)
6674 struct smb_file_time ft
;
6675 uint32 raw_unixmode
;
6678 uid_t set_owner
= (uid_t
)SMB_UID_NO_CHANGE
;
6679 gid_t set_grp
= (uid_t
)SMB_GID_NO_CHANGE
;
6680 NTSTATUS status
= NT_STATUS_OK
;
6681 bool delete_on_fail
= False
;
6682 enum perm_type ptype
;
6683 files_struct
*all_fsps
= NULL
;
6684 bool modify_mtime
= true;
6686 SMB_STRUCT_STAT sbuf
;
6690 if (total_data
< 100) {
6691 return NT_STATUS_INVALID_PARAMETER
;
6694 if(IVAL(pdata
, 0) != SMB_SIZE_NO_CHANGE_LO
&&
6695 IVAL(pdata
, 4) != SMB_SIZE_NO_CHANGE_HI
) {
6696 size
=IVAL(pdata
,0); /* first 8 Bytes are size */
6697 #ifdef LARGE_SMB_OFF_T
6698 size
|= (((SMB_OFF_T
)IVAL(pdata
,4)) << 32);
6699 #else /* LARGE_SMB_OFF_T */
6700 if (IVAL(pdata
,4) != 0) {
6701 /* more than 32 bits? */
6702 return NT_STATUS_INVALID_PARAMETER
;
6704 #endif /* LARGE_SMB_OFF_T */
6707 ft
.atime
= interpret_long_date(pdata
+24); /* access_time */
6708 ft
.mtime
= interpret_long_date(pdata
+32); /* modification_time */
6709 set_owner
= (uid_t
)IVAL(pdata
,40);
6710 set_grp
= (gid_t
)IVAL(pdata
,48);
6711 raw_unixmode
= IVAL(pdata
,84);
6713 if (VALID_STAT(smb_fname
->st
)) {
6714 if (S_ISDIR(smb_fname
->st
.st_ex_mode
)) {
6715 ptype
= PERM_EXISTING_DIR
;
6717 ptype
= PERM_EXISTING_FILE
;
6720 ptype
= PERM_NEW_FILE
;
6723 status
= unix_perms_from_wire(conn
, &smb_fname
->st
, raw_unixmode
,
6725 if (!NT_STATUS_IS_OK(status
)) {
6729 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC: name = "
6730 "%s size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
6731 smb_fname_str_dbg(smb_fname
), (double)size
,
6732 (unsigned int)set_owner
, (unsigned int)set_grp
,
6733 (int)raw_unixmode
));
6735 sbuf
= smb_fname
->st
;
6737 if (!VALID_STAT(sbuf
)) {
6738 struct smb_filename
*smb_fname_tmp
= NULL
;
6740 * The only valid use of this is to create character and block
6741 * devices, and named pipes. This is deprecated (IMHO) and
6742 * a new info level should be used for mknod. JRA.
6745 status
= smb_unix_mknod(conn
,
6749 if (!NT_STATUS_IS_OK(status
)) {
6753 status
= copy_smb_filename(talloc_tos(), smb_fname
,
6755 if (!NT_STATUS_IS_OK(status
)) {
6759 if (SMB_VFS_STAT(conn
, smb_fname_tmp
) != 0) {
6760 status
= map_nt_error_from_unix(errno
);
6761 TALLOC_FREE(smb_fname_tmp
);
6762 SMB_VFS_UNLINK(conn
, smb_fname
);
6766 sbuf
= smb_fname_tmp
->st
;
6767 TALLOC_FREE(smb_fname_tmp
);
6769 /* Ensure we don't try and change anything else. */
6770 raw_unixmode
= SMB_MODE_NO_CHANGE
;
6771 size
= get_file_size_stat(&sbuf
);
6772 ft
.atime
= sbuf
.st_ex_atime
;
6773 ft
.mtime
= sbuf
.st_ex_mtime
;
6775 * We continue here as we might want to change the
6778 delete_on_fail
= True
;
6782 /* Horrible backwards compatibility hack as an old server bug
6783 * allowed a CIFS client bug to remain unnoticed :-(. JRA.
6787 size
= get_file_size_stat(&sbuf
);
6792 * Deal with the UNIX specific mode set.
6795 if (raw_unixmode
!= SMB_MODE_NO_CHANGE
) {
6796 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6797 "setting mode 0%o for file %s\n",
6798 (unsigned int)unixmode
,
6799 smb_fname_str_dbg(smb_fname
)));
6800 if (SMB_VFS_CHMOD(conn
, smb_fname
->base_name
, unixmode
) != 0) {
6801 return map_nt_error_from_unix(errno
);
6806 * Deal with the UNIX specific uid set.
6809 if ((set_owner
!= (uid_t
)SMB_UID_NO_CHANGE
) &&
6810 (sbuf
.st_ex_uid
!= set_owner
)) {
6813 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6814 "changing owner %u for path %s\n",
6815 (unsigned int)set_owner
,
6816 smb_fname_str_dbg(smb_fname
)));
6818 if (S_ISLNK(sbuf
.st_ex_mode
)) {
6819 ret
= SMB_VFS_LCHOWN(conn
, smb_fname
->base_name
,
6820 set_owner
, (gid_t
)-1);
6822 ret
= SMB_VFS_CHOWN(conn
, smb_fname
->base_name
,
6823 set_owner
, (gid_t
)-1);
6827 status
= map_nt_error_from_unix(errno
);
6828 if (delete_on_fail
) {
6829 SMB_VFS_UNLINK(conn
, smb_fname
);
6836 * Deal with the UNIX specific gid set.
6839 if ((set_grp
!= (uid_t
)SMB_GID_NO_CHANGE
) &&
6840 (sbuf
.st_ex_gid
!= set_grp
)) {
6841 DEBUG(10,("smb_set_file_unix_basic: SMB_SET_FILE_UNIX_BASIC "
6842 "changing group %u for file %s\n",
6843 (unsigned int)set_owner
,
6844 smb_fname_str_dbg(smb_fname
)));
6845 if (SMB_VFS_CHOWN(conn
, smb_fname
->base_name
, (uid_t
)-1,
6847 status
= map_nt_error_from_unix(errno
);
6848 if (delete_on_fail
) {
6849 SMB_VFS_UNLINK(conn
, smb_fname
);
6855 /* Deal with any size changes. */
6857 status
= smb_set_file_size(conn
, req
,
6863 if (!NT_STATUS_IS_OK(status
)) {
6867 /* Deal with any time changes. */
6868 if (null_timespec(ft
.mtime
) && null_timespec(ft
.atime
)) {
6869 /* No change, don't cancel anything. */
6873 id
= vfs_file_id_from_sbuf(conn
, &sbuf
);
6874 for(all_fsps
= file_find_di_first(id
); all_fsps
;
6875 all_fsps
= file_find_di_next(all_fsps
)) {
6877 * We're setting the time explicitly for UNIX.
6878 * Cancel any pending changes over all handles.
6880 all_fsps
->update_write_time_on_close
= false;
6881 TALLOC_FREE(all_fsps
->update_write_time_event
);
6885 * Override the "setting_write_time"
6886 * parameter here as it almost does what
6887 * we need. Just remember if we modified
6888 * mtime and send the notify ourselves.
6890 if (null_timespec(ft
.mtime
)) {
6891 modify_mtime
= false;
6894 status
= smb_set_file_time(conn
,
6900 notify_fname(conn
, NOTIFY_ACTION_MODIFIED
,
6901 FILE_NOTIFY_CHANGE_LAST_WRITE
, smb_fname
->base_name
);
6906 /****************************************************************************
6907 Deal with SMB_SET_FILE_UNIX_INFO2.
6908 ****************************************************************************/
6910 static NTSTATUS
smb_set_file_unix_info2(connection_struct
*conn
,
6911 struct smb_request
*req
,
6915 const struct smb_filename
*smb_fname
)
6921 if (total_data
< 116) {
6922 return NT_STATUS_INVALID_PARAMETER
;
6925 /* Start by setting all the fields that are common between UNIX_BASIC
6928 status
= smb_set_file_unix_basic(conn
, req
, pdata
, total_data
,
6930 if (!NT_STATUS_IS_OK(status
)) {
6934 smb_fflags
= IVAL(pdata
, 108);
6935 smb_fmask
= IVAL(pdata
, 112);
6937 /* NB: We should only attempt to alter the file flags if the client
6938 * sends a non-zero mask.
6940 if (smb_fmask
!= 0) {
6941 int stat_fflags
= 0;
6943 if (!map_info2_flags_to_sbuf(&smb_fname
->st
, smb_fflags
,
6944 smb_fmask
, &stat_fflags
)) {
6945 /* Client asked to alter a flag we don't understand. */
6946 return NT_STATUS_INVALID_PARAMETER
;
6949 if (fsp
&& fsp
->fh
->fd
!= -1) {
6950 /* XXX: we should be using SMB_VFS_FCHFLAGS here. */
6951 return NT_STATUS_NOT_SUPPORTED
;
6953 if (SMB_VFS_CHFLAGS(conn
, smb_fname
->base_name
,
6954 stat_fflags
) != 0) {
6955 return map_nt_error_from_unix(errno
);
6960 /* XXX: need to add support for changing the create_time here. You
6961 * can do this for paths on Darwin with setattrlist(2). The right way
6962 * to hook this up is probably by extending the VFS utimes interface.
6965 return NT_STATUS_OK
;
6968 /****************************************************************************
6969 Create a directory with POSIX semantics.
6970 ****************************************************************************/
6972 static NTSTATUS
smb_posix_mkdir(connection_struct
*conn
,
6973 struct smb_request
*req
,
6976 struct smb_filename
*smb_fname
,
6977 int *pdata_return_size
)
6979 NTSTATUS status
= NT_STATUS_OK
;
6980 uint32 raw_unixmode
= 0;
6981 uint32 mod_unixmode
= 0;
6982 mode_t unixmode
= (mode_t
)0;
6983 files_struct
*fsp
= NULL
;
6984 uint16 info_level_return
= 0;
6986 char *pdata
= *ppdata
;
6988 if (total_data
< 18) {
6989 return NT_STATUS_INVALID_PARAMETER
;
6992 raw_unixmode
= IVAL(pdata
,8);
6993 /* Next 4 bytes are not yet defined. */
6995 status
= unix_perms_from_wire(conn
, &smb_fname
->st
, raw_unixmode
,
6996 PERM_NEW_DIR
, &unixmode
);
6997 if (!NT_STATUS_IS_OK(status
)) {
7001 mod_unixmode
= (uint32
)unixmode
| FILE_FLAG_POSIX_SEMANTICS
;
7003 DEBUG(10,("smb_posix_mkdir: file %s, mode 0%o\n",
7004 smb_fname_str_dbg(smb_fname
), (unsigned int)unixmode
));
7006 status
= SMB_VFS_CREATE_FILE(
7009 0, /* root_dir_fid */
7010 smb_fname
, /* fname */
7011 FILE_READ_ATTRIBUTES
, /* access_mask */
7012 FILE_SHARE_NONE
, /* share_access */
7013 FILE_CREATE
, /* create_disposition*/
7014 FILE_DIRECTORY_FILE
, /* create_options */
7015 mod_unixmode
, /* file_attributes */
7016 0, /* oplock_request */
7017 0, /* allocation_size */
7018 0, /* private_flags */
7024 if (NT_STATUS_IS_OK(status
)) {
7025 close_file(req
, fsp
, NORMAL_CLOSE
);
7028 info_level_return
= SVAL(pdata
,16);
7030 if (info_level_return
== SMB_QUERY_FILE_UNIX_BASIC
) {
7031 *pdata_return_size
= 12 + SMB_FILE_UNIX_BASIC_SIZE
;
7032 } else if (info_level_return
== SMB_QUERY_FILE_UNIX_INFO2
) {
7033 *pdata_return_size
= 12 + SMB_FILE_UNIX_INFO2_SIZE
;
7035 *pdata_return_size
= 12;
7038 /* Realloc the data size */
7039 *ppdata
= (char *)SMB_REALLOC(*ppdata
,*pdata_return_size
);
7040 if (*ppdata
== NULL
) {
7041 *pdata_return_size
= 0;
7042 return NT_STATUS_NO_MEMORY
;
7046 SSVAL(pdata
,0,NO_OPLOCK_RETURN
);
7047 SSVAL(pdata
,2,0); /* No fnum. */
7048 SIVAL(pdata
,4,info
); /* Was directory created. */
7050 switch (info_level_return
) {
7051 case SMB_QUERY_FILE_UNIX_BASIC
:
7052 SSVAL(pdata
,8,SMB_QUERY_FILE_UNIX_BASIC
);
7053 SSVAL(pdata
,10,0); /* Padding. */
7054 store_file_unix_basic(conn
, pdata
+ 12, fsp
,
7057 case SMB_QUERY_FILE_UNIX_INFO2
:
7058 SSVAL(pdata
,8,SMB_QUERY_FILE_UNIX_INFO2
);
7059 SSVAL(pdata
,10,0); /* Padding. */
7060 store_file_unix_basic_info2(conn
, pdata
+ 12, fsp
,
7064 SSVAL(pdata
,8,SMB_NO_INFO_LEVEL_RETURNED
);
7065 SSVAL(pdata
,10,0); /* Padding. */
7072 /****************************************************************************
7073 Open/Create a file with POSIX semantics.
7074 ****************************************************************************/
7076 static NTSTATUS
smb_posix_open(connection_struct
*conn
,
7077 struct smb_request
*req
,
7080 struct smb_filename
*smb_fname
,
7081 int *pdata_return_size
)
7083 bool extended_oplock_granted
= False
;
7084 char *pdata
= *ppdata
;
7086 uint32 wire_open_mode
= 0;
7087 uint32 raw_unixmode
= 0;
7088 uint32 mod_unixmode
= 0;
7089 uint32 create_disp
= 0;
7090 uint32 access_mask
= 0;
7091 uint32 create_options
= 0;
7092 NTSTATUS status
= NT_STATUS_OK
;
7093 mode_t unixmode
= (mode_t
)0;
7094 files_struct
*fsp
= NULL
;
7095 int oplock_request
= 0;
7097 uint16 info_level_return
= 0;
7099 if (total_data
< 18) {
7100 return NT_STATUS_INVALID_PARAMETER
;
7103 flags
= IVAL(pdata
,0);
7104 oplock_request
= (flags
& REQUEST_OPLOCK
) ? EXCLUSIVE_OPLOCK
: 0;
7105 if (oplock_request
) {
7106 oplock_request
|= (flags
& REQUEST_BATCH_OPLOCK
) ? BATCH_OPLOCK
: 0;
7109 wire_open_mode
= IVAL(pdata
,4);
7111 if (wire_open_mode
== (SMB_O_CREAT
|SMB_O_DIRECTORY
)) {
7112 return smb_posix_mkdir(conn
, req
,
7119 switch (wire_open_mode
& SMB_ACCMODE
) {
7121 access_mask
= FILE_READ_DATA
;
7124 access_mask
= FILE_WRITE_DATA
;
7127 access_mask
= FILE_READ_DATA
|FILE_WRITE_DATA
;
7130 DEBUG(5,("smb_posix_open: invalid open mode 0x%x\n",
7131 (unsigned int)wire_open_mode
));
7132 return NT_STATUS_INVALID_PARAMETER
;
7135 wire_open_mode
&= ~SMB_ACCMODE
;
7137 if((wire_open_mode
& (SMB_O_CREAT
| SMB_O_EXCL
)) == (SMB_O_CREAT
| SMB_O_EXCL
)) {
7138 create_disp
= FILE_CREATE
;
7139 } else if((wire_open_mode
& (SMB_O_CREAT
| SMB_O_TRUNC
)) == (SMB_O_CREAT
| SMB_O_TRUNC
)) {
7140 create_disp
= FILE_OVERWRITE_IF
;
7141 } else if((wire_open_mode
& SMB_O_CREAT
) == SMB_O_CREAT
) {
7142 create_disp
= FILE_OPEN_IF
;
7143 } else if ((wire_open_mode
& (SMB_O_CREAT
| SMB_O_EXCL
| SMB_O_TRUNC
)) == 0) {
7144 create_disp
= FILE_OPEN
;
7146 DEBUG(5,("smb_posix_open: invalid create mode 0x%x\n",
7147 (unsigned int)wire_open_mode
));
7148 return NT_STATUS_INVALID_PARAMETER
;
7151 raw_unixmode
= IVAL(pdata
,8);
7152 /* Next 4 bytes are not yet defined. */
7154 status
= unix_perms_from_wire(conn
, &smb_fname
->st
, raw_unixmode
,
7155 (VALID_STAT(smb_fname
->st
) ?
7156 PERM_EXISTING_FILE
: PERM_NEW_FILE
),
7159 if (!NT_STATUS_IS_OK(status
)) {
7163 mod_unixmode
= (uint32
)unixmode
| FILE_FLAG_POSIX_SEMANTICS
;
7165 if (wire_open_mode
& SMB_O_SYNC
) {
7166 create_options
|= FILE_WRITE_THROUGH
;
7168 if (wire_open_mode
& SMB_O_APPEND
) {
7169 access_mask
|= FILE_APPEND_DATA
;
7171 if (wire_open_mode
& SMB_O_DIRECT
) {
7172 mod_unixmode
|= FILE_FLAG_NO_BUFFERING
;
7175 DEBUG(10,("smb_posix_open: file %s, smb_posix_flags = %u, mode 0%o\n",
7176 smb_fname_str_dbg(smb_fname
),
7177 (unsigned int)wire_open_mode
,
7178 (unsigned int)unixmode
));
7180 status
= SMB_VFS_CREATE_FILE(
7183 0, /* root_dir_fid */
7184 smb_fname
, /* fname */
7185 access_mask
, /* access_mask */
7186 (FILE_SHARE_READ
| FILE_SHARE_WRITE
| /* share_access */
7188 create_disp
, /* create_disposition*/
7189 FILE_NON_DIRECTORY_FILE
, /* create_options */
7190 mod_unixmode
, /* file_attributes */
7191 oplock_request
, /* oplock_request */
7192 0, /* allocation_size */
7193 0, /* private_flags */
7199 if (!NT_STATUS_IS_OK(status
)) {
7203 if (oplock_request
&& lp_fake_oplocks(SNUM(conn
))) {
7204 extended_oplock_granted
= True
;
7207 if(oplock_request
&& EXCLUSIVE_OPLOCK_TYPE(fsp
->oplock_type
)) {
7208 extended_oplock_granted
= True
;
7211 info_level_return
= SVAL(pdata
,16);
7213 /* Allocate the correct return size. */
7215 if (info_level_return
== SMB_QUERY_FILE_UNIX_BASIC
) {
7216 *pdata_return_size
= 12 + SMB_FILE_UNIX_BASIC_SIZE
;
7217 } else if (info_level_return
== SMB_QUERY_FILE_UNIX_INFO2
) {
7218 *pdata_return_size
= 12 + SMB_FILE_UNIX_INFO2_SIZE
;
7220 *pdata_return_size
= 12;
7223 /* Realloc the data size */
7224 *ppdata
= (char *)SMB_REALLOC(*ppdata
,*pdata_return_size
);
7225 if (*ppdata
== NULL
) {
7226 close_file(req
, fsp
, ERROR_CLOSE
);
7227 *pdata_return_size
= 0;
7228 return NT_STATUS_NO_MEMORY
;
7232 if (extended_oplock_granted
) {
7233 if (flags
& REQUEST_BATCH_OPLOCK
) {
7234 SSVAL(pdata
,0, BATCH_OPLOCK_RETURN
);
7236 SSVAL(pdata
,0, EXCLUSIVE_OPLOCK_RETURN
);
7238 } else if (fsp
->oplock_type
== LEVEL_II_OPLOCK
) {
7239 SSVAL(pdata
,0, LEVEL_II_OPLOCK_RETURN
);
7241 SSVAL(pdata
,0,NO_OPLOCK_RETURN
);
7244 SSVAL(pdata
,2,fsp
->fnum
);
7245 SIVAL(pdata
,4,info
); /* Was file created etc. */
7247 switch (info_level_return
) {
7248 case SMB_QUERY_FILE_UNIX_BASIC
:
7249 SSVAL(pdata
,8,SMB_QUERY_FILE_UNIX_BASIC
);
7250 SSVAL(pdata
,10,0); /* padding. */
7251 store_file_unix_basic(conn
, pdata
+ 12, fsp
,
7254 case SMB_QUERY_FILE_UNIX_INFO2
:
7255 SSVAL(pdata
,8,SMB_QUERY_FILE_UNIX_INFO2
);
7256 SSVAL(pdata
,10,0); /* padding. */
7257 store_file_unix_basic_info2(conn
, pdata
+ 12, fsp
,
7261 SSVAL(pdata
,8,SMB_NO_INFO_LEVEL_RETURNED
);
7262 SSVAL(pdata
,10,0); /* padding. */
7265 return NT_STATUS_OK
;
7268 /****************************************************************************
7269 Delete a file with POSIX semantics.
7270 ****************************************************************************/
7272 static NTSTATUS
smb_posix_unlink(connection_struct
*conn
,
7273 struct smb_request
*req
,
7276 struct smb_filename
*smb_fname
)
7278 NTSTATUS status
= NT_STATUS_OK
;
7279 files_struct
*fsp
= NULL
;
7283 int create_options
= 0;
7285 struct share_mode_lock
*lck
= NULL
;
7287 if (total_data
< 2) {
7288 return NT_STATUS_INVALID_PARAMETER
;
7291 flags
= SVAL(pdata
,0);
7293 if (!VALID_STAT(smb_fname
->st
)) {
7294 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
7297 if ((flags
== SMB_POSIX_UNLINK_DIRECTORY_TARGET
) &&
7298 !VALID_STAT_OF_DIR(smb_fname
->st
)) {
7299 return NT_STATUS_NOT_A_DIRECTORY
;
7302 DEBUG(10,("smb_posix_unlink: %s %s\n",
7303 (flags
== SMB_POSIX_UNLINK_DIRECTORY_TARGET
) ? "directory" : "file",
7304 smb_fname_str_dbg(smb_fname
)));
7306 if (VALID_STAT_OF_DIR(smb_fname
->st
)) {
7307 create_options
|= FILE_DIRECTORY_FILE
;
7310 status
= SMB_VFS_CREATE_FILE(
7313 0, /* root_dir_fid */
7314 smb_fname
, /* fname */
7315 DELETE_ACCESS
, /* access_mask */
7316 (FILE_SHARE_READ
| FILE_SHARE_WRITE
| /* share_access */
7318 FILE_OPEN
, /* create_disposition*/
7319 create_options
, /* create_options */
7320 FILE_FLAG_POSIX_SEMANTICS
|0777, /* file_attributes */
7321 0, /* oplock_request */
7322 0, /* allocation_size */
7323 0, /* private_flags */
7329 if (!NT_STATUS_IS_OK(status
)) {
7334 * Don't lie to client. If we can't really delete due to
7335 * non-POSIX opens return SHARING_VIOLATION.
7338 lck
= get_share_mode_lock(talloc_tos(), fsp
->file_id
, NULL
, NULL
,
7341 DEBUG(0, ("smb_posix_unlink: Could not get share mode "
7342 "lock for file %s\n", fsp_str_dbg(fsp
)));
7343 close_file(req
, fsp
, NORMAL_CLOSE
);
7344 return NT_STATUS_INVALID_PARAMETER
;
7348 * See if others still have the file open. If this is the case, then
7349 * don't delete. If all opens are POSIX delete we can set the delete
7350 * on close disposition.
7352 for (i
=0; i
<lck
->num_share_modes
; i
++) {
7353 struct share_mode_entry
*e
= &lck
->share_modes
[i
];
7354 if (is_valid_share_mode_entry(e
)) {
7355 if (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
) {
7358 /* Fail with sharing violation. */
7359 close_file(req
, fsp
, NORMAL_CLOSE
);
7361 return NT_STATUS_SHARING_VIOLATION
;
7366 * Set the delete on close.
7368 status
= smb_set_file_disposition_info(conn
,
7374 if (!NT_STATUS_IS_OK(status
)) {
7375 close_file(req
, fsp
, NORMAL_CLOSE
);
7380 return close_file(req
, fsp
, NORMAL_CLOSE
);
7383 NTSTATUS
smbd_do_setfilepathinfo(connection_struct
*conn
,
7384 struct smb_request
*req
,
7385 TALLOC_CTX
*mem_ctx
,
7386 uint16_t info_level
,
7388 struct smb_filename
*smb_fname
,
7389 char **ppdata
, int total_data
,
7392 char *pdata
= *ppdata
;
7393 NTSTATUS status
= NT_STATUS_OK
;
7394 int data_return_size
= 0;
7398 if (INFO_LEVEL_IS_UNIX(info_level
) && !lp_unix_extensions()) {
7399 return NT_STATUS_INVALID_LEVEL
;
7402 if (!CAN_WRITE(conn
)) {
7403 /* Allow POSIX opens. The open path will deny
7404 * any non-readonly opens. */
7405 if (info_level
!= SMB_POSIX_PATH_OPEN
) {
7406 return NT_STATUS_DOS(ERRSRV
, ERRaccess
);
7410 DEBUG(3,("smbd_do_setfilepathinfo: %s (fnum %d) info_level=%d "
7411 "totdata=%d\n", smb_fname_str_dbg(smb_fname
),
7412 fsp
? fsp
->fnum
: -1, info_level
, total_data
));
7414 switch (info_level
) {
7416 case SMB_INFO_STANDARD
:
7418 status
= smb_set_info_standard(conn
,
7426 case SMB_INFO_SET_EA
:
7428 status
= smb_info_set_ea(conn
,
7436 case SMB_SET_FILE_BASIC_INFO
:
7437 case SMB_FILE_BASIC_INFORMATION
:
7439 status
= smb_set_file_basic_info(conn
,
7447 case SMB_FILE_ALLOCATION_INFORMATION
:
7448 case SMB_SET_FILE_ALLOCATION_INFO
:
7450 status
= smb_set_file_allocation_info(conn
, req
,
7458 case SMB_FILE_END_OF_FILE_INFORMATION
:
7459 case SMB_SET_FILE_END_OF_FILE_INFO
:
7462 * XP/Win7 both fail after the createfile with
7463 * SMB_SET_FILE_END_OF_FILE_INFO but not
7464 * SMB_FILE_END_OF_FILE_INFORMATION (pass-through).
7465 * The level is known here, so pass it down
7469 (info_level
== SMB_SET_FILE_END_OF_FILE_INFO
);
7471 status
= smb_set_file_end_of_file_info(conn
, req
,
7480 case SMB_FILE_DISPOSITION_INFORMATION
:
7481 case SMB_SET_FILE_DISPOSITION_INFO
: /* Set delete on close for open file. */
7484 /* JRA - We used to just ignore this on a path ?
7485 * Shouldn't this be invalid level on a pathname
7488 if (tran_call
!= TRANSACT2_SETFILEINFO
) {
7489 return ERROR_NT(NT_STATUS_INVALID_LEVEL
);
7492 status
= smb_set_file_disposition_info(conn
,
7500 case SMB_FILE_POSITION_INFORMATION
:
7502 status
= smb_file_position_information(conn
,
7509 case SMB_FILE_FULL_EA_INFORMATION
:
7511 status
= smb_set_file_full_ea_info(conn
,
7518 /* From tridge Samba4 :
7519 * MODE_INFORMATION in setfileinfo (I have no
7520 * idea what "mode information" on a file is - it takes a value of 0,
7521 * 2, 4 or 6. What could it be?).
7524 case SMB_FILE_MODE_INFORMATION
:
7526 status
= smb_file_mode_information(conn
,
7533 * CIFS UNIX extensions.
7536 case SMB_SET_FILE_UNIX_BASIC
:
7538 status
= smb_set_file_unix_basic(conn
, req
,
7546 case SMB_SET_FILE_UNIX_INFO2
:
7548 status
= smb_set_file_unix_info2(conn
, req
,
7556 case SMB_SET_FILE_UNIX_LINK
:
7559 /* We must have a pathname for this. */
7560 return NT_STATUS_INVALID_LEVEL
;
7562 status
= smb_set_file_unix_link(conn
, req
, pdata
,
7563 total_data
, smb_fname
);
7567 case SMB_SET_FILE_UNIX_HLINK
:
7570 /* We must have a pathname for this. */
7571 return NT_STATUS_INVALID_LEVEL
;
7573 status
= smb_set_file_unix_hlink(conn
, req
,
7579 case SMB_FILE_RENAME_INFORMATION
:
7581 status
= smb_file_rename_information(conn
, req
,
7587 case SMB2_FILE_RENAME_INFORMATION_INTERNAL
:
7589 /* SMB2 rename information. */
7590 status
= smb2_file_rename_information(conn
, req
,
7596 #if defined(HAVE_POSIX_ACLS)
7597 case SMB_SET_POSIX_ACL
:
7599 status
= smb_set_posix_acl(conn
,
7608 case SMB_SET_POSIX_LOCK
:
7611 return NT_STATUS_INVALID_LEVEL
;
7613 status
= smb_set_posix_lock(conn
, req
,
7614 pdata
, total_data
, fsp
);
7618 case SMB_POSIX_PATH_OPEN
:
7621 /* We must have a pathname for this. */
7622 return NT_STATUS_INVALID_LEVEL
;
7625 status
= smb_posix_open(conn
, req
,
7633 case SMB_POSIX_PATH_UNLINK
:
7636 /* We must have a pathname for this. */
7637 return NT_STATUS_INVALID_LEVEL
;
7640 status
= smb_posix_unlink(conn
, req
,
7648 return NT_STATUS_INVALID_LEVEL
;
7651 if (!NT_STATUS_IS_OK(status
)) {
7655 *ret_data_size
= data_return_size
;
7656 return NT_STATUS_OK
;
7659 /****************************************************************************
7660 Reply to a TRANS2_SETFILEINFO (set file info by fileid or pathname).
7661 ****************************************************************************/
7663 static void call_trans2setfilepathinfo(connection_struct
*conn
,
7664 struct smb_request
*req
,
7665 unsigned int tran_call
,
7666 char **pparams
, int total_params
,
7667 char **ppdata
, int total_data
,
7668 unsigned int max_data_bytes
)
7670 char *params
= *pparams
;
7671 char *pdata
= *ppdata
;
7673 struct smb_filename
*smb_fname
= NULL
;
7674 files_struct
*fsp
= NULL
;
7675 NTSTATUS status
= NT_STATUS_OK
;
7676 int data_return_size
= 0;
7679 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7683 if (tran_call
== TRANSACT2_SETFILEINFO
) {
7684 if (total_params
< 4) {
7685 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7689 fsp
= file_fsp(req
, SVAL(params
,0));
7690 /* Basic check for non-null fsp. */
7691 if (!check_fsp_open(conn
, req
, fsp
)) {
7694 info_level
= SVAL(params
,2);
7696 status
= copy_smb_filename(talloc_tos(), fsp
->fsp_name
,
7698 if (!NT_STATUS_IS_OK(status
)) {
7699 reply_nterror(req
, status
);
7703 if(fsp
->is_directory
|| fsp
->fh
->fd
== -1) {
7705 * This is actually a SETFILEINFO on a directory
7706 * handle (returned from an NT SMB). NT5.0 seems
7707 * to do this call. JRA.
7709 if (INFO_LEVEL_IS_UNIX(info_level
)) {
7710 /* Always do lstat for UNIX calls. */
7711 if (SMB_VFS_LSTAT(conn
, smb_fname
)) {
7712 DEBUG(3,("call_trans2setfilepathinfo: "
7713 "SMB_VFS_LSTAT of %s failed "
7715 smb_fname_str_dbg(smb_fname
),
7717 reply_nterror(req
, map_nt_error_from_unix(errno
));
7721 if (SMB_VFS_STAT(conn
, smb_fname
) != 0) {
7722 DEBUG(3,("call_trans2setfilepathinfo: "
7723 "fileinfo of %s failed (%s)\n",
7724 smb_fname_str_dbg(smb_fname
),
7726 reply_nterror(req
, map_nt_error_from_unix(errno
));
7730 } else if (fsp
->print_file
) {
7732 * Doing a DELETE_ON_CLOSE should cancel a print job.
7734 if ((info_level
== SMB_SET_FILE_DISPOSITION_INFO
) && CVAL(pdata
,0)) {
7735 fsp
->fh
->private_options
|= NTCREATEX_OPTIONS_PRIVATE_DELETE_ON_CLOSE
;
7737 DEBUG(3,("call_trans2setfilepathinfo: "
7738 "Cancelling print job (%s)\n",
7742 send_trans2_replies(conn
, req
, params
, 2,
7748 NT_STATUS_OBJECT_PATH_NOT_FOUND
);
7753 * Original code - this is an open file.
7755 if (!check_fsp(conn
, req
, fsp
)) {
7759 if (SMB_VFS_FSTAT(fsp
, &smb_fname
->st
) != 0) {
7760 DEBUG(3,("call_trans2setfilepathinfo: fstat "
7761 "of fnum %d failed (%s)\n", fsp
->fnum
,
7763 reply_nterror(req
, map_nt_error_from_unix(errno
));
7771 if (total_params
< 7) {
7772 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7776 info_level
= SVAL(params
,0);
7777 srvstr_get_path(req
, params
, req
->flags2
, &fname
, ¶ms
[6],
7778 total_params
- 6, STR_TERMINATE
,
7780 if (!NT_STATUS_IS_OK(status
)) {
7781 reply_nterror(req
, status
);
7785 status
= filename_convert(req
, conn
,
7786 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
7791 if (!NT_STATUS_IS_OK(status
)) {
7792 if (NT_STATUS_EQUAL(status
,NT_STATUS_PATH_NOT_COVERED
)) {
7793 reply_botherror(req
,
7794 NT_STATUS_PATH_NOT_COVERED
,
7795 ERRSRV
, ERRbadpath
);
7798 reply_nterror(req
, status
);
7802 if (INFO_LEVEL_IS_UNIX(info_level
)) {
7804 * For CIFS UNIX extensions the target name may not exist.
7807 /* Always do lstat for UNIX calls. */
7808 SMB_VFS_LSTAT(conn
, smb_fname
);
7810 } else if (!VALID_STAT(smb_fname
->st
) &&
7811 SMB_VFS_STAT(conn
, smb_fname
)) {
7812 DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of "
7814 smb_fname_str_dbg(smb_fname
),
7816 reply_nterror(req
, map_nt_error_from_unix(errno
));
7821 DEBUG(3,("call_trans2setfilepathinfo(%d) %s (fnum %d) info_level=%d "
7822 "totdata=%d\n", tran_call
, smb_fname_str_dbg(smb_fname
),
7823 fsp
? fsp
->fnum
: -1, info_level
,total_data
));
7825 /* Realloc the parameter size */
7826 *pparams
= (char *)SMB_REALLOC(*pparams
,2);
7827 if (*pparams
== NULL
) {
7828 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
7835 status
= smbd_do_setfilepathinfo(conn
, req
, req
,
7841 if (!NT_STATUS_IS_OK(status
)) {
7842 if (open_was_deferred(req
->mid
)) {
7843 /* We have re-scheduled this call. */
7846 if (blocking_lock_was_deferred(req
->mid
)) {
7847 /* We have re-scheduled this call. */
7850 if (NT_STATUS_EQUAL(status
,NT_STATUS_PATH_NOT_COVERED
)) {
7851 reply_botherror(req
, NT_STATUS_PATH_NOT_COVERED
,
7852 ERRSRV
, ERRbadpath
);
7855 if (info_level
== SMB_POSIX_PATH_OPEN
) {
7856 reply_openerror(req
, status
);
7860 reply_nterror(req
, status
);
7864 send_trans2_replies(conn
, req
, params
, 2, *ppdata
, data_return_size
,
7870 /****************************************************************************
7871 Reply to a TRANS2_MKDIR (make directory with extended attributes).
7872 ****************************************************************************/
7874 static void call_trans2mkdir(connection_struct
*conn
, struct smb_request
*req
,
7875 char **pparams
, int total_params
,
7876 char **ppdata
, int total_data
,
7877 unsigned int max_data_bytes
)
7879 struct smb_filename
*smb_dname
= NULL
;
7880 char *params
= *pparams
;
7881 char *pdata
= *ppdata
;
7882 char *directory
= NULL
;
7883 NTSTATUS status
= NT_STATUS_OK
;
7884 struct ea_list
*ea_list
= NULL
;
7885 TALLOC_CTX
*ctx
= talloc_tos();
7887 if (!CAN_WRITE(conn
)) {
7888 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
7892 if (total_params
< 5) {
7893 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7897 srvstr_get_path(ctx
, params
, req
->flags2
, &directory
, ¶ms
[4],
7898 total_params
- 4, STR_TERMINATE
,
7900 if (!NT_STATUS_IS_OK(status
)) {
7901 reply_nterror(req
, status
);
7905 DEBUG(3,("call_trans2mkdir : name = %s\n", directory
));
7907 status
= filename_convert(ctx
,
7909 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
7915 if (!NT_STATUS_IS_OK(status
)) {
7916 if (NT_STATUS_EQUAL(status
,NT_STATUS_PATH_NOT_COVERED
)) {
7917 reply_botherror(req
,
7918 NT_STATUS_PATH_NOT_COVERED
,
7919 ERRSRV
, ERRbadpath
);
7922 reply_nterror(req
, status
);
7927 * OS/2 workplace shell seems to send SET_EA requests of "null"
7928 * length (4 bytes containing IVAL 4).
7929 * They seem to have no effect. Bug #3212. JRA.
7932 if (total_data
&& (total_data
!= 4)) {
7933 /* Any data in this call is an EA list. */
7934 if (total_data
< 10) {
7935 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7939 if (IVAL(pdata
,0) > total_data
) {
7940 DEBUG(10,("call_trans2mkdir: bad total data size (%u) > %u\n",
7941 IVAL(pdata
,0), (unsigned int)total_data
));
7942 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7946 ea_list
= read_ea_list(talloc_tos(), pdata
+ 4,
7949 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
7953 if (!lp_ea_support(SNUM(conn
))) {
7954 reply_nterror(req
, NT_STATUS_EAS_NOT_SUPPORTED
);
7958 /* If total_data == 4 Windows doesn't care what values
7959 * are placed in that field, it just ignores them.
7960 * The System i QNTC IBM SMB client puts bad values here,
7961 * so ignore them. */
7963 status
= create_directory(conn
, req
, smb_dname
);
7965 if (!NT_STATUS_IS_OK(status
)) {
7966 reply_nterror(req
, status
);
7970 /* Try and set any given EA. */
7972 status
= set_ea(conn
, NULL
, smb_dname
, ea_list
);
7973 if (!NT_STATUS_IS_OK(status
)) {
7974 reply_nterror(req
, status
);
7979 /* Realloc the parameter and data sizes */
7980 *pparams
= (char *)SMB_REALLOC(*pparams
,2);
7981 if(*pparams
== NULL
) {
7982 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
7989 send_trans2_replies(conn
, req
, params
, 2, *ppdata
, 0, max_data_bytes
);
7992 TALLOC_FREE(smb_dname
);
7996 /****************************************************************************
7997 Reply to a TRANS2_FINDNOTIFYFIRST (start monitoring a directory for changes).
7998 We don't actually do this - we just send a null response.
7999 ****************************************************************************/
8001 static void call_trans2findnotifyfirst(connection_struct
*conn
,
8002 struct smb_request
*req
,
8003 char **pparams
, int total_params
,
8004 char **ppdata
, int total_data
,
8005 unsigned int max_data_bytes
)
8007 char *params
= *pparams
;
8010 if (total_params
< 6) {
8011 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8015 info_level
= SVAL(params
,4);
8016 DEBUG(3,("call_trans2findnotifyfirst - info_level %d\n", info_level
));
8018 switch (info_level
) {
8023 reply_nterror(req
, NT_STATUS_INVALID_LEVEL
);
8027 /* Realloc the parameter and data sizes */
8028 *pparams
= (char *)SMB_REALLOC(*pparams
,6);
8029 if (*pparams
== NULL
) {
8030 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
8035 SSVAL(params
,0,fnf_handle
);
8036 SSVAL(params
,2,0); /* No changes */
8037 SSVAL(params
,4,0); /* No EA errors */
8044 send_trans2_replies(conn
, req
, params
, 6, *ppdata
, 0, max_data_bytes
);
8049 /****************************************************************************
8050 Reply to a TRANS2_FINDNOTIFYNEXT (continue monitoring a directory for
8051 changes). Currently this does nothing.
8052 ****************************************************************************/
8054 static void call_trans2findnotifynext(connection_struct
*conn
,
8055 struct smb_request
*req
,
8056 char **pparams
, int total_params
,
8057 char **ppdata
, int total_data
,
8058 unsigned int max_data_bytes
)
8060 char *params
= *pparams
;
8062 DEBUG(3,("call_trans2findnotifynext\n"));
8064 /* Realloc the parameter and data sizes */
8065 *pparams
= (char *)SMB_REALLOC(*pparams
,4);
8066 if (*pparams
== NULL
) {
8067 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
8072 SSVAL(params
,0,0); /* No changes */
8073 SSVAL(params
,2,0); /* No EA errors */
8075 send_trans2_replies(conn
, req
, params
, 4, *ppdata
, 0, max_data_bytes
);
8080 /****************************************************************************
8081 Reply to a TRANS2_GET_DFS_REFERRAL - Shirish Kalele <kalele@veritas.com>.
8082 ****************************************************************************/
8084 static void call_trans2getdfsreferral(connection_struct
*conn
,
8085 struct smb_request
*req
,
8086 char **pparams
, int total_params
,
8087 char **ppdata
, int total_data
,
8088 unsigned int max_data_bytes
)
8090 char *params
= *pparams
;
8091 char *pathname
= NULL
;
8093 int max_referral_level
;
8094 NTSTATUS status
= NT_STATUS_OK
;
8095 TALLOC_CTX
*ctx
= talloc_tos();
8097 DEBUG(10,("call_trans2getdfsreferral\n"));
8099 if (total_params
< 3) {
8100 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8104 max_referral_level
= SVAL(params
,0);
8106 if(!lp_host_msdfs()) {
8107 reply_nterror(req
, NT_STATUS_NOT_IMPLEMENTED
);
8111 srvstr_pull_talloc(ctx
, params
, req
->flags2
, &pathname
, ¶ms
[2],
8112 total_params
- 2, STR_TERMINATE
);
8114 reply_nterror(req
, NT_STATUS_NOT_FOUND
);
8117 if((reply_size
= setup_dfs_referral(conn
, pathname
, max_referral_level
,
8118 ppdata
,&status
)) < 0) {
8119 reply_nterror(req
, status
);
8123 SSVAL(req
->inbuf
, smb_flg2
,
8124 SVAL(req
->inbuf
,smb_flg2
) | FLAGS2_DFS_PATHNAMES
);
8125 send_trans2_replies(conn
, req
,0,0,*ppdata
,reply_size
, max_data_bytes
);
8130 #define LMCAT_SPL 0x53
8131 #define LMFUNC_GETJOBID 0x60
8133 /****************************************************************************
8134 Reply to a TRANS2_IOCTL - used for OS/2 printing.
8135 ****************************************************************************/
8137 static void call_trans2ioctl(connection_struct
*conn
,
8138 struct smb_request
*req
,
8139 char **pparams
, int total_params
,
8140 char **ppdata
, int total_data
,
8141 unsigned int max_data_bytes
)
8143 char *pdata
= *ppdata
;
8144 files_struct
*fsp
= file_fsp(req
, SVAL(req
->vwv
+15, 0));
8146 /* check for an invalid fid before proceeding */
8149 reply_nterror(req
, NT_STATUS_INVALID_HANDLE
);
8153 if ((SVAL(req
->vwv
+16, 0) == LMCAT_SPL
)
8154 && (SVAL(req
->vwv
+17, 0) == LMFUNC_GETJOBID
)) {
8155 *ppdata
= (char *)SMB_REALLOC(*ppdata
, 32);
8156 if (*ppdata
== NULL
) {
8157 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
8162 /* NOTE - THIS IS ASCII ONLY AT THE MOMENT - NOT SURE IF OS/2
8163 CAN ACCEPT THIS IN UNICODE. JRA. */
8165 SSVAL(pdata
,0,fsp
->rap_print_jobid
); /* Job number */
8166 srvstr_push(pdata
, req
->flags2
, pdata
+ 2,
8167 global_myname(), 15,
8168 STR_ASCII
|STR_TERMINATE
); /* Our NetBIOS name */
8169 srvstr_push(pdata
, req
->flags2
, pdata
+18,
8170 lp_servicename(SNUM(conn
)), 13,
8171 STR_ASCII
|STR_TERMINATE
); /* Service name */
8172 send_trans2_replies(conn
, req
, *pparams
, 0, *ppdata
, 32,
8177 DEBUG(2,("Unknown TRANS2_IOCTL\n"));
8178 reply_nterror(req
, NT_STATUS_NOT_IMPLEMENTED
);
8181 /****************************************************************************
8182 Reply to a SMBfindclose (stop trans2 directory search).
8183 ****************************************************************************/
8185 void reply_findclose(struct smb_request
*req
)
8188 struct smbd_server_connection
*sconn
= smbd_server_conn
;
8190 START_PROFILE(SMBfindclose
);
8193 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8194 END_PROFILE(SMBfindclose
);
8198 dptr_num
= SVALS(req
->vwv
+0, 0);
8200 DEBUG(3,("reply_findclose, dptr_num = %d\n", dptr_num
));
8202 dptr_close(sconn
, &dptr_num
);
8204 reply_outbuf(req
, 0, 0);
8206 DEBUG(3,("SMBfindclose dptr_num = %d\n", dptr_num
));
8208 END_PROFILE(SMBfindclose
);
8212 /****************************************************************************
8213 Reply to a SMBfindnclose (stop FINDNOTIFYFIRST directory search).
8214 ****************************************************************************/
8216 void reply_findnclose(struct smb_request
*req
)
8220 START_PROFILE(SMBfindnclose
);
8223 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8224 END_PROFILE(SMBfindnclose
);
8228 dptr_num
= SVAL(req
->vwv
+0, 0);
8230 DEBUG(3,("reply_findnclose, dptr_num = %d\n", dptr_num
));
8232 /* We never give out valid handles for a
8233 findnotifyfirst - so any dptr_num is ok here.
8236 reply_outbuf(req
, 0, 0);
8238 DEBUG(3,("SMB_findnclose dptr_num = %d\n", dptr_num
));
8240 END_PROFILE(SMBfindnclose
);
8244 static void handle_trans2(connection_struct
*conn
, struct smb_request
*req
,
8245 struct trans_state
*state
)
8247 if (get_Protocol() >= PROTOCOL_NT1
) {
8248 req
->flags2
|= 0x40; /* IS_LONG_NAME */
8249 SSVAL(req
->inbuf
,smb_flg2
,req
->flags2
);
8252 if (conn
->encrypt_level
== Required
&& !req
->encrypted
) {
8253 if (state
->call
!= TRANSACT2_QFSINFO
&&
8254 state
->call
!= TRANSACT2_SETFSINFO
) {
8255 DEBUG(0,("handle_trans2: encryption required "
8257 (unsigned int)state
->call
));
8258 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
8263 SMB_PERFCOUNT_SET_SUBOP(&req
->pcd
, state
->call
);
8265 /* Now we must call the relevant TRANS2 function */
8266 switch(state
->call
) {
8267 case TRANSACT2_OPEN
:
8269 START_PROFILE(Trans2_open
);
8270 call_trans2open(conn
, req
,
8271 &state
->param
, state
->total_param
,
8272 &state
->data
, state
->total_data
,
8273 state
->max_data_return
);
8274 END_PROFILE(Trans2_open
);
8278 case TRANSACT2_FINDFIRST
:
8280 START_PROFILE(Trans2_findfirst
);
8281 call_trans2findfirst(conn
, req
,
8282 &state
->param
, state
->total_param
,
8283 &state
->data
, state
->total_data
,
8284 state
->max_data_return
);
8285 END_PROFILE(Trans2_findfirst
);
8289 case TRANSACT2_FINDNEXT
:
8291 START_PROFILE(Trans2_findnext
);
8292 call_trans2findnext(conn
, req
,
8293 &state
->param
, state
->total_param
,
8294 &state
->data
, state
->total_data
,
8295 state
->max_data_return
);
8296 END_PROFILE(Trans2_findnext
);
8300 case TRANSACT2_QFSINFO
:
8302 START_PROFILE(Trans2_qfsinfo
);
8303 call_trans2qfsinfo(conn
, req
,
8304 &state
->param
, state
->total_param
,
8305 &state
->data
, state
->total_data
,
8306 state
->max_data_return
);
8307 END_PROFILE(Trans2_qfsinfo
);
8311 case TRANSACT2_SETFSINFO
:
8313 START_PROFILE(Trans2_setfsinfo
);
8314 call_trans2setfsinfo(conn
, req
,
8315 &state
->param
, state
->total_param
,
8316 &state
->data
, state
->total_data
,
8317 state
->max_data_return
);
8318 END_PROFILE(Trans2_setfsinfo
);
8322 case TRANSACT2_QPATHINFO
:
8323 case TRANSACT2_QFILEINFO
:
8325 START_PROFILE(Trans2_qpathinfo
);
8326 call_trans2qfilepathinfo(conn
, req
, state
->call
,
8327 &state
->param
, state
->total_param
,
8328 &state
->data
, state
->total_data
,
8329 state
->max_data_return
);
8330 END_PROFILE(Trans2_qpathinfo
);
8334 case TRANSACT2_SETPATHINFO
:
8335 case TRANSACT2_SETFILEINFO
:
8337 START_PROFILE(Trans2_setpathinfo
);
8338 call_trans2setfilepathinfo(conn
, req
, state
->call
,
8339 &state
->param
, state
->total_param
,
8340 &state
->data
, state
->total_data
,
8341 state
->max_data_return
);
8342 END_PROFILE(Trans2_setpathinfo
);
8346 case TRANSACT2_FINDNOTIFYFIRST
:
8348 START_PROFILE(Trans2_findnotifyfirst
);
8349 call_trans2findnotifyfirst(conn
, req
,
8350 &state
->param
, state
->total_param
,
8351 &state
->data
, state
->total_data
,
8352 state
->max_data_return
);
8353 END_PROFILE(Trans2_findnotifyfirst
);
8357 case TRANSACT2_FINDNOTIFYNEXT
:
8359 START_PROFILE(Trans2_findnotifynext
);
8360 call_trans2findnotifynext(conn
, req
,
8361 &state
->param
, state
->total_param
,
8362 &state
->data
, state
->total_data
,
8363 state
->max_data_return
);
8364 END_PROFILE(Trans2_findnotifynext
);
8368 case TRANSACT2_MKDIR
:
8370 START_PROFILE(Trans2_mkdir
);
8371 call_trans2mkdir(conn
, req
,
8372 &state
->param
, state
->total_param
,
8373 &state
->data
, state
->total_data
,
8374 state
->max_data_return
);
8375 END_PROFILE(Trans2_mkdir
);
8379 case TRANSACT2_GET_DFS_REFERRAL
:
8381 START_PROFILE(Trans2_get_dfs_referral
);
8382 call_trans2getdfsreferral(conn
, req
,
8383 &state
->param
, state
->total_param
,
8384 &state
->data
, state
->total_data
,
8385 state
->max_data_return
);
8386 END_PROFILE(Trans2_get_dfs_referral
);
8390 case TRANSACT2_IOCTL
:
8392 START_PROFILE(Trans2_ioctl
);
8393 call_trans2ioctl(conn
, req
,
8394 &state
->param
, state
->total_param
,
8395 &state
->data
, state
->total_data
,
8396 state
->max_data_return
);
8397 END_PROFILE(Trans2_ioctl
);
8402 /* Error in request */
8403 DEBUG(2,("Unknown request %d in trans2 call\n", state
->call
));
8404 reply_nterror(req
, NT_STATUS_NOT_IMPLEMENTED
);
8408 /****************************************************************************
8409 Reply to a SMBtrans2.
8410 ****************************************************************************/
8412 void reply_trans2(struct smb_request
*req
)
8414 connection_struct
*conn
= req
->conn
;
8419 unsigned int tran_call
;
8420 struct trans_state
*state
;
8423 START_PROFILE(SMBtrans2
);
8425 if (req
->wct
< 14) {
8426 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8427 END_PROFILE(SMBtrans2
);
8431 dsoff
= SVAL(req
->vwv
+12, 0);
8432 dscnt
= SVAL(req
->vwv
+11, 0);
8433 psoff
= SVAL(req
->vwv
+10, 0);
8434 pscnt
= SVAL(req
->vwv
+9, 0);
8435 tran_call
= SVAL(req
->vwv
+14, 0);
8437 result
= allow_new_trans(conn
->pending_trans
, req
->mid
);
8438 if (!NT_STATUS_IS_OK(result
)) {
8439 DEBUG(2, ("Got invalid trans2 request: %s\n",
8440 nt_errstr(result
)));
8441 reply_nterror(req
, result
);
8442 END_PROFILE(SMBtrans2
);
8447 switch (tran_call
) {
8448 /* List the allowed trans2 calls on IPC$ */
8449 case TRANSACT2_OPEN
:
8450 case TRANSACT2_GET_DFS_REFERRAL
:
8451 case TRANSACT2_QFILEINFO
:
8452 case TRANSACT2_QFSINFO
:
8453 case TRANSACT2_SETFSINFO
:
8456 reply_nterror(req
, NT_STATUS_ACCESS_DENIED
);
8457 END_PROFILE(SMBtrans2
);
8462 if ((state
= TALLOC_P(conn
, struct trans_state
)) == NULL
) {
8463 DEBUG(0, ("talloc failed\n"));
8464 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
8465 END_PROFILE(SMBtrans2
);
8469 state
->cmd
= SMBtrans2
;
8471 state
->mid
= req
->mid
;
8472 state
->vuid
= req
->vuid
;
8473 state
->setup_count
= SVAL(req
->vwv
+13, 0);
8474 state
->setup
= NULL
;
8475 state
->total_param
= SVAL(req
->vwv
+0, 0);
8476 state
->param
= NULL
;
8477 state
->total_data
= SVAL(req
->vwv
+1, 0);
8479 state
->max_param_return
= SVAL(req
->vwv
+2, 0);
8480 state
->max_data_return
= SVAL(req
->vwv
+3, 0);
8481 state
->max_setup_return
= SVAL(req
->vwv
+4, 0);
8482 state
->close_on_completion
= BITSETW(req
->vwv
+5, 0);
8483 state
->one_way
= BITSETW(req
->vwv
+5, 1);
8485 state
->call
= tran_call
;
8487 /* All trans2 messages we handle have smb_sucnt == 1 - ensure this
8488 is so as a sanity check */
8489 if (state
->setup_count
!= 1) {
8491 * Need to have rc=0 for ioctl to get job id for OS/2.
8492 * Network printing will fail if function is not successful.
8493 * Similar function in reply.c will be used if protocol
8494 * is LANMAN1.0 instead of LM1.2X002.
8495 * Until DosPrintSetJobInfo with PRJINFO3 is supported,
8496 * outbuf doesn't have to be set(only job id is used).
8498 if ( (state
->setup_count
== 4)
8499 && (tran_call
== TRANSACT2_IOCTL
)
8500 && (SVAL(req
->vwv
+16, 0) == LMCAT_SPL
)
8501 && (SVAL(req
->vwv
+17, 0) == LMFUNC_GETJOBID
)) {
8502 DEBUG(2,("Got Trans2 DevIOctl jobid\n"));
8504 DEBUG(2,("Invalid smb_sucnt in trans2 call(%u)\n",state
->setup_count
));
8505 DEBUG(2,("Transaction is %d\n",tran_call
));
8507 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8508 END_PROFILE(SMBtrans2
);
8513 if ((dscnt
> state
->total_data
) || (pscnt
> state
->total_param
))
8516 if (state
->total_data
) {
8518 if (trans_oob(state
->total_data
, 0, dscnt
)
8519 || trans_oob(smb_len(req
->inbuf
), dsoff
, dscnt
)) {
8523 /* Can't use talloc here, the core routines do realloc on the
8524 * params and data. */
8525 state
->data
= (char *)SMB_MALLOC(state
->total_data
);
8526 if (state
->data
== NULL
) {
8527 DEBUG(0,("reply_trans2: data malloc fail for %u "
8528 "bytes !\n", (unsigned int)state
->total_data
));
8530 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
8531 END_PROFILE(SMBtrans2
);
8535 memcpy(state
->data
,smb_base(req
->inbuf
)+dsoff
,dscnt
);
8538 if (state
->total_param
) {
8540 if (trans_oob(state
->total_param
, 0, pscnt
)
8541 || trans_oob(smb_len(req
->inbuf
), psoff
, pscnt
)) {
8545 /* Can't use talloc here, the core routines do realloc on the
8546 * params and data. */
8547 state
->param
= (char *)SMB_MALLOC(state
->total_param
);
8548 if (state
->param
== NULL
) {
8549 DEBUG(0,("reply_trans: param malloc fail for %u "
8550 "bytes !\n", (unsigned int)state
->total_param
));
8551 SAFE_FREE(state
->data
);
8553 reply_nterror(req
, NT_STATUS_NO_MEMORY
);
8554 END_PROFILE(SMBtrans2
);
8558 memcpy(state
->param
,smb_base(req
->inbuf
)+psoff
,pscnt
);
8561 state
->received_data
= dscnt
;
8562 state
->received_param
= pscnt
;
8564 if ((state
->received_param
== state
->total_param
) &&
8565 (state
->received_data
== state
->total_data
)) {
8567 handle_trans2(conn
, req
, state
);
8569 SAFE_FREE(state
->data
);
8570 SAFE_FREE(state
->param
);
8572 END_PROFILE(SMBtrans2
);
8576 DLIST_ADD(conn
->pending_trans
, state
);
8578 /* We need to send an interim response then receive the rest
8579 of the parameter/data bytes */
8580 reply_outbuf(req
, 0, 0);
8581 show_msg((char *)req
->outbuf
);
8582 END_PROFILE(SMBtrans2
);
8587 DEBUG(0,("reply_trans2: invalid trans parameters\n"));
8588 SAFE_FREE(state
->data
);
8589 SAFE_FREE(state
->param
);
8591 END_PROFILE(SMBtrans2
);
8592 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8596 /****************************************************************************
8597 Reply to a SMBtranss2
8598 ****************************************************************************/
8600 void reply_transs2(struct smb_request
*req
)
8602 connection_struct
*conn
= req
->conn
;
8603 unsigned int pcnt
,poff
,dcnt
,doff
,pdisp
,ddisp
;
8604 struct trans_state
*state
;
8606 START_PROFILE(SMBtranss2
);
8608 show_msg((char *)req
->inbuf
);
8611 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8612 END_PROFILE(SMBtranss2
);
8616 for (state
= conn
->pending_trans
; state
!= NULL
;
8617 state
= state
->next
) {
8618 if (state
->mid
== req
->mid
) {
8623 if ((state
== NULL
) || (state
->cmd
!= SMBtrans2
)) {
8624 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8625 END_PROFILE(SMBtranss2
);
8629 /* Revise state->total_param and state->total_data in case they have
8630 changed downwards */
8632 if (SVAL(req
->vwv
+0, 0) < state
->total_param
)
8633 state
->total_param
= SVAL(req
->vwv
+0, 0);
8634 if (SVAL(req
->vwv
+1, 0) < state
->total_data
)
8635 state
->total_data
= SVAL(req
->vwv
+1, 0);
8637 pcnt
= SVAL(req
->vwv
+2, 0);
8638 poff
= SVAL(req
->vwv
+3, 0);
8639 pdisp
= SVAL(req
->vwv
+4, 0);
8641 dcnt
= SVAL(req
->vwv
+5, 0);
8642 doff
= SVAL(req
->vwv
+6, 0);
8643 ddisp
= SVAL(req
->vwv
+7, 0);
8645 state
->received_param
+= pcnt
;
8646 state
->received_data
+= dcnt
;
8648 if ((state
->received_data
> state
->total_data
) ||
8649 (state
->received_param
> state
->total_param
))
8653 if (trans_oob(state
->total_param
, pdisp
, pcnt
)
8654 || trans_oob(smb_len(req
->inbuf
), poff
, pcnt
)) {
8657 memcpy(state
->param
+pdisp
,smb_base(req
->inbuf
)+poff
,pcnt
);
8661 if (trans_oob(state
->total_data
, ddisp
, dcnt
)
8662 || trans_oob(smb_len(req
->inbuf
), doff
, dcnt
)) {
8665 memcpy(state
->data
+ddisp
, smb_base(req
->inbuf
)+doff
,dcnt
);
8668 if ((state
->received_param
< state
->total_param
) ||
8669 (state
->received_data
< state
->total_data
)) {
8670 END_PROFILE(SMBtranss2
);
8674 handle_trans2(conn
, req
, state
);
8676 DLIST_REMOVE(conn
->pending_trans
, state
);
8677 SAFE_FREE(state
->data
);
8678 SAFE_FREE(state
->param
);
8681 END_PROFILE(SMBtranss2
);
8686 DEBUG(0,("reply_transs2: invalid trans parameters\n"));
8687 DLIST_REMOVE(conn
->pending_trans
, state
);
8688 SAFE_FREE(state
->data
);
8689 SAFE_FREE(state
->param
);
8691 reply_nterror(req
, NT_STATUS_INVALID_PARAMETER
);
8692 END_PROFILE(SMBtranss2
);